Constify trait aliases

oli-obk · oli-obk · commit 6de4d4166709 · 2025-07-24T07:25:13.000Z
diff --git a/compiler/rustc_ast/src/ast.rs b/compiler/rustc_ast/src/ast.rs
@@ -3701,6 +3701,7 @@ 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)]
diff --git a/compiler/rustc_ast/src/visit.rs b/compiler/rustc_ast/src/visit.rs
@@ -836,8 +836,8 @@ macro_rules! common_visitor_and_walkers {
                         visit_visitable!($($mut)? vis, impl_),
                     ItemKind::Trait(trait_) =>
                         visit_visitable!($($mut)? vis, trait_),
-                    ItemKind::TraitAlias(box TraitAlias { ident, generics, bounds }) => {
-                        visit_visitable!($($mut)? vis, ident, generics);
+                    ItemKind::TraitAlias(box TraitAlias { ident, generics, bounds, constness}) => {
+                        visit_visitable!($($mut)? vis, ident, generics, constness);
                         visit_visitable_with!($($mut)? vis, bounds, BoundKind::Bound)
                     }
                     ItemKind::MacCall(m) =>
diff --git a/compiler/rustc_ast_lowering/src/item.rs b/compiler/rustc_ast_lowering/src/item.rs
@@ -444,7 +444,7 @@ impl<'hir> LoweringContext<'_, 'hir> {
                 );
                 hir::ItemKind::Trait(constness, *is_auto, safety, ident, generics, bounds, items)
             }
-            ItemKind::TraitAlias(box TraitAlias { ident, generics, bounds }) => {
+            ItemKind::TraitAlias(box TraitAlias { ident, generics, bounds, constness }) => {
                 let ident = self.lower_ident(*ident);
                 let (generics, bounds) = self.lower_generics(
                     generics,
@@ -458,7 +458,8 @@ impl<'hir> LoweringContext<'_, 'hir> {
                         )
                     },
                 );
-                hir::ItemKind::TraitAlias(ident, generics, bounds)
+                let constness = self.lower_constness(*constness);
+                hir::ItemKind::TraitAlias(constness, ident, generics, bounds)
             }
             ItemKind::MacroDef(ident, MacroDef { body, macro_rules }) => {
                 let ident = self.lower_ident(*ident);
diff --git a/compiler/rustc_ast_pretty/src/pprust/state/item.rs b/compiler/rustc_ast_pretty/src/pprust/state/item.rs
@@ -386,8 +386,11 @@ impl<'a> State<'a> {
                 let empty = item.attrs.is_empty() && items.is_empty();
                 self.bclose(item.span, empty, cb);
             }
-            ast::ItemKind::TraitAlias(box TraitAlias { ident, generics, bounds }) => {
-                let (cb, ib) = self.head(visibility_qualified(&item.vis, "trait"));
+            ast::ItemKind::TraitAlias(box TraitAlias { ident, generics, bounds, constness }) => {
+                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();
diff --git a/compiler/rustc_hir/src/hir.rs b/compiler/rustc_hir/src/hir.rs
@@ -4175,8 +4175,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, &'hir Impl<'hir>, ItemKind::Impl(imp), imp;
     }
@@ -4353,7 +4353,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(&'hir Impl<'hir>),
@@ -4396,7 +4396,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 { .. }
@@ -4414,7 +4414,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,
         })
diff --git a/compiler/rustc_hir/src/intravisit.rs b/compiler/rustc_hir/src/intravisit.rs
@@ -632,7 +632,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);
diff --git a/compiler/rustc_hir_analysis/src/collect/predicates_of.rs b/compiler/rustc_hir_analysis/src/collect/predicates_of.rs
@@ -164,7 +164,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));
             }
             _ => {}
@@ -656,7 +656,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"),
     };
 
diff --git a/compiler/rustc_hir_analysis/src/collect/resolve_bound_vars.rs b/compiler/rustc_hir_analysis/src/collect/resolve_bound_vars.rs
@@ -635,7 +635,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));
diff --git a/compiler/rustc_hir_analysis/src/hir_ty_lowering/bounds.rs b/compiler/rustc_hir_analysis/src/hir_ty_lowering/bounds.rs
@@ -330,7 +330,7 @@ impl<'tcx> dyn HirTyLowerer<'tcx> + '_ {
 
         let (trait_generics, trait_bounds) = match parent_trait.kind {
             hir::ItemKind::Trait(_, _, _, _, generics, supertraits, _) => (generics, supertraits),
-            hir::ItemKind::TraitAlias(_, generics, supertraits) => (generics, supertraits),
+            hir::ItemKind::TraitAlias(_, _, generics, supertraits) => (generics, supertraits),
             _ => unreachable!(),
         };
 
diff --git a/compiler/rustc_hir_pretty/src/lib.rs b/compiler/rustc_hir_pretty/src/lib.rs
@@ -760,8 +760,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();
diff --git a/compiler/rustc_hir_typeck/src/method/suggest.rs b/compiler/rustc_hir_typeck/src/method/suggest.rs
@@ -1202,7 +1202,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
diff --git a/compiler/rustc_parse/messages.ftl b/compiler/rustc_parse/messages.ftl
@@ -855,7 +855,6 @@ parse_trailing_vert_not_allowed = a trailing `|` is not allowed in an or-pattern
     .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_transpose_dyn_or_impl = `for<...>` expected after `{$kw}`, not before
diff --git a/compiler/rustc_parse/src/errors.rs b/compiler/rustc_parse/src/errors.rs
@@ -1961,14 +1961,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 {
diff --git a/compiler/rustc_parse/src/parser/item.rs b/compiler/rustc_parse/src/parser/item.rs
@@ -916,9 +916,6 @@ impl<'a> Parser<'a> {
             self.expect_semi()?;
 
             let whole_span = lo.to(self.prev_token.span);
-            if let Const::Yes(_) = constness {
-                self.dcx().emit_err(errors::TraitAliasCannotBeConst { span: whole_span });
-            }
             if is_auto == IsAuto::Yes {
                 self.dcx().emit_err(errors::TraitAliasCannotBeAuto { span: whole_span });
             }
@@ -928,7 +925,7 @@ impl<'a> Parser<'a> {
 
             self.psess.gated_spans.gate(sym::trait_alias, whole_span);
 
-            Ok(ItemKind::TraitAlias(Box::new(TraitAlias { ident, generics, bounds })))
+            Ok(ItemKind::TraitAlias(Box::new(TraitAlias { ident, generics, bounds, constness })))
         } else {
             // It's a normal trait.
             generics.where_clause = self.parse_where_clause()?;
diff --git a/compiler/rustc_trait_selection/src/error_reporting/traits/mod.rs b/compiler/rustc_trait_selection/src/error_reporting/traits/mod.rs
@@ -453,9 +453,8 @@ pub fn report_dyn_incompatibility<'tcx>(
     let trait_str = tcx.def_path_str(trait_def_id);
     let trait_span = tcx.hir_get_if_local(trait_def_id).and_then(|node| match node {
         hir::Node::Item(item) => match item.kind {
-            hir::ItemKind::Trait(_, _, _, ident, ..) | hir::ItemKind::TraitAlias(ident, _, _) => {
-                Some(ident.span)
-            }
+            hir::ItemKind::Trait(_, _, _, ident, ..)
+            | hir::ItemKind::TraitAlias(_, ident, _, _) => Some(ident.span),
             _ => unreachable!(),
         },
         _ => None,
diff --git a/compiler/rustc_trait_selection/src/error_reporting/traits/suggestions.rs b/compiler/rustc_trait_selection/src/error_reporting/traits/suggestions.rs
@@ -360,7 +360,7 @@ impl<'a, 'tcx> TypeErrCtxt<'a, 'tcx> {
                         | hir::ItemKind::Fn { generics, .. }
                         | hir::ItemKind::TyAlias(_, generics, _)
                         | hir::ItemKind::Const(_, generics, _, _)
-                        | hir::ItemKind::TraitAlias(_, generics, _),
+                        | hir::ItemKind::TraitAlias(_, _, generics, _),
                     ..
                 })
                 | hir::Node::TraitItem(hir::TraitItem { generics, .. })
@@ -420,7 +420,7 @@ impl<'a, 'tcx> TypeErrCtxt<'a, 'tcx> {
                         | hir::ItemKind::Fn { generics, .. }
                         | hir::ItemKind::TyAlias(_, generics, _)
                         | hir::ItemKind::Const(_, generics, _, _)
-                        | hir::ItemKind::TraitAlias(_, generics, _),
+                        | hir::ItemKind::TraitAlias(_, _, generics, _),
                     ..
                 }) if !param_ty => {
                     // Missing generic type parameter bound.
diff --git a/src/librustdoc/clean/mod.rs b/src/librustdoc/clean/mod.rs
@@ -2843,7 +2843,7 @@ fn clean_maybe_renamed_item<'tcx>(
                 variants: def.variants.iter().map(|v| clean_variant(v, cx)).collect(),
                 generics: clean_generics(generics, cx),
             }),
-            ItemKind::TraitAlias(_, generics, bounds) => TraitAliasItem(TraitAlias {
+            ItemKind::TraitAlias(_, _, generics, bounds) => TraitAliasItem(TraitAlias {
                 generics: clean_generics(generics, cx),
                 bounds: bounds.iter().filter_map(|x| clean_generic_bound(x, cx)).collect(),
             }),
diff --git a/src/tools/clippy/clippy_utils/src/ast_utils/mod.rs b/src/tools/clippy/clippy_utils/src/ast_utils/mod.rs
@@ -475,13 +475,20 @@ pub fn eq_item_kind(l: &ItemKind, r: &ItemKind) -> bool {
                 ident: li,
                 generics: lg,
                 bounds: lb,
+                constness: lc,
             }),
             TraitAlias(box ast::TraitAlias {
                 ident: ri,
                 generics: rg,
                 bounds: rb,
+                constness: rc,
             }),
-        ) => eq_id(*li, *ri) && eq_generics(lg, rg) && over(lb, rb, eq_generic_bound),
+        ) => {
+            matches!(lc, ast::Const::No) == matches!(rc, ast::Const::No)
+                && eq_id(*li, *ri)
+                && eq_generics(lg, rg)
+                && over(lb, rb, eq_generic_bound)
+        },
         (
             Impl(box ast::Impl {
                 safety: lu,
diff --git a/tests/ui/consts/trait_alias.fail.stderr b/tests/ui/consts/trait_alias.fail.stderr
@@ -0,0 +1,46 @@
+error: `[const]` is not allowed here
+  --> $DIR/trait_alias.rs:14:19
+   |
+LL | const trait Foo = [const] Bar + Baz;
+   |                   ^^^^^^^
+   |
+   = note: this item cannot have `[const]` trait bounds
+
+error: `[const]` can only be applied to `const` traits
+  --> $DIR/trait_alias.rs:17:17
+   |
+LL | const fn foo<T: [const] Foo>(x: &T) {
+   |                 ^^^^^^^ can't be applied to `Foo`
+   |
+help: mark `Foo` as `const` to allow it to have `const` implementations
+   |
+LL | #[const_trait] const trait Foo = [const] Bar + Baz;
+   | ++++++++++++++
+
+error: `[const]` can only be applied to `const` traits
+  --> $DIR/trait_alias.rs:17:17
+   |
+LL | const fn foo<T: [const] Foo>(x: &T) {
+   |                 ^^^^^^^ can't be applied to `Foo`
+   |
+   = note: duplicate diagnostic emitted due to `-Z deduplicate-diagnostics=no`
+help: mark `Foo` as `const` to allow it to have `const` implementations
+   |
+LL | #[const_trait] const trait Foo = [const] Bar + Baz;
+   | ++++++++++++++
+
+error[E0277]: the trait bound `T: [const] Bar` is not satisfied
+  --> $DIR/trait_alias.rs:20:7
+   |
+LL |     x.bar();
+   |       ^^^
+
+error[E0277]: the trait bound `T: [const] Baz` is not satisfied
+  --> $DIR/trait_alias.rs:24:11
+   |
+LL |         x.baz();
+   |           ^^^
+
+error: aborting due to 5 previous errors
+
+For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/consts/trait_alias.pass.stderr b/tests/ui/consts/trait_alias.pass.stderr
@@ -0,0 +1,40 @@
+error: `[const]` is not allowed here
+  --> $DIR/trait_alias.rs:14:19
+   |
+LL | const trait Foo = [const] Bar + Baz;
+   |                   ^^^^^^^
+   |
+   = note: this item cannot have `[const]` trait bounds
+
+error: `[const]` can only be applied to `const` traits
+  --> $DIR/trait_alias.rs:17:17
+   |
+LL | const fn foo<T: [const] Foo>(x: &T) {
+   |                 ^^^^^^^ can't be applied to `Foo`
+   |
+help: mark `Foo` as `const` to allow it to have `const` implementations
+   |
+LL | #[const_trait] const trait Foo = [const] Bar + Baz;
+   | ++++++++++++++
+
+error: `[const]` can only be applied to `const` traits
+  --> $DIR/trait_alias.rs:17:17
+   |
+LL | const fn foo<T: [const] Foo>(x: &T) {
+   |                 ^^^^^^^ can't be applied to `Foo`
+   |
+   = note: duplicate diagnostic emitted due to `-Z deduplicate-diagnostics=no`
+help: mark `Foo` as `const` to allow it to have `const` implementations
+   |
+LL | #[const_trait] const trait Foo = [const] Bar + Baz;
+   | ++++++++++++++
+
+error[E0277]: the trait bound `T: [const] Bar` is not satisfied
+  --> $DIR/trait_alias.rs:20:7
+   |
+LL |     x.bar();
+   |       ^^^
+
+error: aborting due to 4 previous errors
+
+For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/consts/trait_alias.rs b/tests/ui/consts/trait_alias.rs
@@ -0,0 +1,31 @@
+#![feature(trait_alias, const_trait_impl)]
+//@ revisions: pass fail
+
+const trait Bar {
+    fn bar(&self) {}
+}
+const trait Baz {
+    fn baz(&self) {}
+}
+
+impl const Bar for () {}
+impl const Baz for () {}
+
+const trait Foo = [const] Bar + Baz;
+//~^ ERROR: `[const]` is not allowed here
+
+const fn foo<T: [const] Foo>(x: &T) {
+    //~^ ERROR: `[const]` can only be applied to `const` traits
+    //~| ERROR: `[const]` can only be applied to `const` traits
+    x.bar();
+    //~^ ERROR: the trait bound `T: [const] Bar` is not satisfied
+    #[cfg(fail)]
+    {
+        x.baz();
+        //[fail]~^ ERROR: the trait bound `T: [const] Baz` is not satisfied
+    }
+}
+
+const _: () = foo(&());
+
+fn main() {}

Original file line number	Diff line number	Diff line change
`@@ -444,7 +444,7 @@ impl<'hir> LoweringContext<'_, 'hir> {`
`444`	`444`	`);`
`445`	`445`	`hir::ItemKind::Trait(constness, *is_auto, safety, ident, generics, bounds, items)`
`446`	`446`	`}`
`447`		`- ItemKind::TraitAlias(box TraitAlias { ident, generics, bounds }) => {`
	`447`	`+ ItemKind::TraitAlias(box TraitAlias { ident, generics, bounds, constness }) => {`
`448`	`448`	`let ident = self.lower_ident(*ident);`
`449`	`449`	`let (generics, bounds) = self.lower_generics(`
`450`	`450`	`generics,`
`@@ -458,7 +458,8 @@ impl<'hir> LoweringContext<'_, 'hir> {`
`458`	`458`	`)`
`459`	`459`	`},`
`460`	`460`	`);`
`461`		`- hir::ItemKind::TraitAlias(ident, generics, bounds)`
	`461`	`+ let constness = self.lower_constness(*constness);`
	`462`	`+ hir::ItemKind::TraitAlias(constness, ident, generics, bounds)`
`462`	`463`	`}`
`463`	`464`	`ItemKind::MacroDef(ident, MacroDef { body, macro_rules }) => {`
`464`	`465`	`let ident = self.lower_ident(*ident);`
Original file line number	Diff line number	Diff line change
`@@ -632,7 +632,7 @@ pub fn walk_item<'v, V: Visitor<'v>>(visitor: &mut V, item: &'v Item<'v>) -> V::`
`632`	`632`	`walk_list!(visitor, visit_param_bound, bounds);`
`633`	`633`	`walk_list!(visitor, visit_trait_item_ref, trait_item_refs);`
`634`	`634`	`}`
`635`		`- ItemKind::TraitAlias(ident, ref generics, bounds) => {`
	`635`	`+ ItemKind::TraitAlias(_constness, ident, ref generics, bounds) => {`
`636`	`636`	`try_visit!(visitor.visit_ident(ident));`
`637`	`637`	`try_visit!(visitor.visit_generics(generics));`
`638`	`638`	`walk_list!(visitor, visit_param_bound, bounds);`
Original file line number	Diff line number	Diff line change
`@@ -164,7 +164,7 @@ fn gather_explicit_predicates_of(tcx: TyCtxt<'_>, def_id: LocalDefId) -> ty::Gen`
`164`	`164`	`}`
`165`	`165`	`}`
`166`	`166`	`ItemKind::Trait(_, _, _, _, _, self_bounds, ..)`
`167`		`- \| ItemKind::TraitAlias(_, _, self_bounds) => {`
	`167`	`+ \| ItemKind::TraitAlias(_, _, _, self_bounds) => {`
`168`	`168`	`is_trait = Some((self_bounds, item.span));`
`169`	`169`	`}`
`170`	`170`	`_ => {}`
`@@ -656,7 +656,7 @@ pub(super) fn implied_predicates_with_filter<'tcx>(`
`656`	`656`
`657`	`657`	`let (generics, superbounds) = match item.kind {`
`658`	`658`	`hir::ItemKind::Trait(.., generics, supertraits, _) => (generics, supertraits),`
`659`		`- hir::ItemKind::TraitAlias(_, generics, supertraits) => (generics, supertraits),`
	`659`	`+ hir::ItemKind::TraitAlias(_, _, generics, supertraits) => (generics, supertraits),`
`660`	`660`	`_ => span_bug!(item.span, "super_predicates invoked on non-trait"),`
`661`	`661`	`};`
`662`	`662`
Original file line number	Diff line number	Diff line change
`@@ -760,8 +760,10 @@ impl<'a> State<'a> {`
`760`	`760`	`}`
`761`	`761`	`self.bclose(item.span, cb);`
`762`	`762`	`}`
`763`		`- hir::ItemKind::TraitAlias(ident, generics, bounds) => {`
`764`		`- let (cb, ib) = self.head("trait");`
	`763`	`+ hir::ItemKind::TraitAlias(constness, ident, generics, bounds) => {`
	`764`	`+ let (cb, ib) = self.head("");`
	`765`	`+ self.print_constness(constness);`
	`766`	`+ self.word_nbsp("trait");`
`765`	`767`	`self.print_ident(ident);`
`766`	`768`	`self.print_generic_params(generics.params);`
`767`	`769`	`self.nbsp();`