Constify trait aliases

compiler/rustc_ast/src/ast.rs

@@ -3538,8 +3538,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),
@@ -3621,6 +3622,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,
@@ -3816,7 +3826,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> { .. }`.
@@ -3849,7 +3859,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),
 
@@ -3906,7 +3916,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,
         }
@@ -4068,8 +4078,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

@@ -835,8 +835,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

@@ -417,7 +417,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,
@@ -431,7 +432,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

@@ -1197,6 +1197,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;
@@ -388,8 +387,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

@@ -4237,8 +4237,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;
     }
@@ -4415,7 +4415,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>),
@@ -4460,7 +4460,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 { .. }
@@ -4478,7 +4478,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

@@ -166,7 +166,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));
             }
             _ => {}
@@ -651,7 +651,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"),
     };
 
@@ -1014,7 +1014,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:?}"),
         },
@@ -1070,12 +1073,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,
@@ -1123,13 +1128,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));

compiler/rustc_hir_pretty/src/lib.rs

@@ -765,8 +765,10 @@ impl<'a> State<'a> {
                 }
                 self.bclose(item.span, cb);
             }
-            hir::ItemKind::TraitAlias(ident, generics, bounds) => {
-                let (cb, ib) = self.head("trait");
+            hir::ItemKind::TraitAlias(constness, ident, generics, bounds) => {
+                let (cb, ib) = self.head("");
+                self.print_constness(constness);
+                self.word_nbsp("trait");
                 self.print_ident(ident);
                 self.print_generic_params(generics.params);
                 self.nbsp();

compiler/rustc_hir_typeck/src/method/suggest.rs

@@ -1187,7 +1187,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
                         Node::Item(hir::Item {
                             kind:
                                 hir::ItemKind::Trait(_, _, _, ident, ..)
-                                | hir::ItemKind::TraitAlias(ident, ..),
+                                | hir::ItemKind::TraitAlias(_, ident, ..),
                             ..
                         })
                         // We may also encounter unsatisfied GAT or method bounds

compiler/rustc_lint/src/nonstandard_style.rs

@@ -160,7 +160,9 @@ impl EarlyLintPass for NonCamelCaseTypes {
             ast::ItemKind::Trait(box ast::Trait { ident, .. }) => {
                 self.check_case(cx, "trait", ident)
             }
-            ast::ItemKind::TraitAlias(ident, _, _) => self.check_case(cx, "trait alias", ident),
+            ast::ItemKind::TraitAlias(box ast::TraitAlias { ident, .. }) => {
+                self.check_case(cx, "trait alias", ident)
+            }
 
             // N.B. This check is only for inherent associated types, so that we don't lint against
             // trait impls where we should have warned for the trait definition already.

compiler/rustc_middle/src/ty/mod.rs

@@ -2068,7 +2068,7 @@ impl<'tcx> TyCtxt<'tcx> {
             DefKind::Fn | DefKind::Ctor(_, CtorKind::Fn) => {
                 self.constness(def_id) == hir::Constness::Const
             }
-            DefKind::Trait => self.is_const_trait(def_id),
+            DefKind::TraitAlias | DefKind::Trait => self.is_const_trait(def_id),
             DefKind::AssocTy => {
                 let parent_def_id = self.parent(def_id);
                 match self.def_kind(parent_def_id) {
@@ -2111,7 +2111,6 @@ impl<'tcx> TyCtxt<'tcx> {
             | DefKind::Variant
             | DefKind::TyAlias
             | DefKind::ForeignTy
-            | DefKind::TraitAlias
             | DefKind::TyParam
             | DefKind::Const
             | DefKind::ConstParam

compiler/rustc_next_trait_solver/src/solve/effect_goals.rs

@@ -196,10 +196,35 @@ where
     }
 
     fn consider_trait_alias_candidate(
-        _ecx: &mut EvalCtxt<'_, D>,
-        _goal: Goal<I, Self>,
+        ecx: &mut EvalCtxt<'_, D>,
+        goal: Goal<I, Self>,
     ) -> Result<Candidate<I>, NoSolution> {
-        unreachable!("trait aliases are never const")
+        let cx = ecx.cx();
+
+        ecx.probe_builtin_trait_candidate(BuiltinImplSource::Misc).enter(|ecx| {
+            let where_clause_bounds = cx
+                .predicates_of(goal.predicate.def_id().into())
+                .iter_instantiated(cx, goal.predicate.trait_ref.args)
+                .map(|p| goal.with(cx, p));
+            ecx.add_goals(GoalSource::Misc, where_clause_bounds);
+
+            let const_conditions = cx
+                .const_conditions(goal.predicate.def_id().into())
+                .iter_instantiated(cx, goal.predicate.trait_ref.args)
+                .map(|bound_trait_ref| {
+                    goal.with(
+                        cx,
+                        bound_trait_ref.to_host_effect_clause(cx, goal.predicate.constness),
+                    )
+                });
+            // While you could think of trait aliases to have a single builtin impl
+            // which uses its implied trait bounds as where-clauses, using
+            // `GoalSource::ImplWhereClause` here would be incorrect, as we also
+            // impl them, which means we're "stepping out of the impl constructor"
+            // again. To handle this, we treat these cycles as ambiguous for now.
+            ecx.add_goals(GoalSource::Misc, const_conditions);
+            ecx.evaluate_added_goals_and_make_canonical_response(Certainty::Yes)
+        })
     }
 
     fn consider_builtin_sizedness_candidates(

compiler/rustc_parse/messages.ftl

@@ -871,7 +871,6 @@ parse_trailing_vert_not_allowed = a trailing `{$token}` is not allowed in an or-
 parse_trailing_vert_not_allowed_suggestion = remove the `{$token}`
 
 parse_trait_alias_cannot_be_auto = trait aliases cannot be `auto`
-parse_trait_alias_cannot_be_const = trait aliases cannot be `const`
 parse_trait_alias_cannot_be_unsafe = trait aliases cannot be `unsafe`
 
 parse_trait_impl_modifier_in_inherent_impl = inherent impls cannot be {$modifier_name}

compiler/rustc_parse/src/errors.rs

@@ -1999,14 +1999,6 @@ pub(crate) struct TraitAliasCannotBeAuto {
     pub span: Span,
 }
 
-#[derive(Diagnostic)]
-#[diag(parse_trait_alias_cannot_be_const)]
-pub(crate) struct TraitAliasCannotBeConst {
-    #[primary_span]
-    #[label(parse_trait_alias_cannot_be_const)]
-    pub span: Span,
-}
-
 #[derive(Diagnostic)]
 #[diag(parse_trait_alias_cannot_be_unsafe)]
 pub(crate) struct TraitAliasCannotBeUnsafe {