rustfmt impl restriction

Author: CoCo-Japan-pan

src/tools/rustfmt/src/items.rs

@@ -1158,6 +1158,7 @@ pub(crate) fn format_trait(
         constness,
         is_auto,
         safety,
+        ref impl_restriction,
         ident,
         ref generics,
         ref bounds,
@@ -1166,11 +1167,12 @@ pub(crate) fn format_trait(
 
     let mut result = String::with_capacity(128);
     let header = format!(
-        "{}{}{}{}trait ",
+        "{}{}{}{}{}trait ",
         format_visibility(context, &item.vis),
         format_constness(constness),
         format_safety(safety),
         format_auto(is_auto),
+        format_impl_restriction(context, impl_restriction),
     );
     result.push_str(&header);
 

src/tools/rustfmt/src/utils.rs

@@ -2,8 +2,8 @@ use std::borrow::Cow;
 
 use rustc_ast::YieldKind;
 use rustc_ast::ast::{
-    self, Attribute, MetaItem, MetaItemInner, MetaItemKind, NodeId, Path, Visibility,
-    VisibilityKind,
+    self, Attribute, ImplRestriction, MetaItem, MetaItemInner, MetaItemKind, NodeId, Path,
+    RestrictionKind, Visibility, VisibilityKind,
 };
 use rustc_ast_pretty::pprust;
 use rustc_span::{BytePos, LocalExpnId, Span, Symbol, SyntaxContext, sym, symbol};
@@ -74,6 +74,40 @@ pub(crate) fn format_visibility(
     }
 }
 
+pub(crate) fn format_impl_restriction(
+    context: &RewriteContext<'_>,
+    impl_restriction: &ImplRestriction,
+) -> String {
+    format_restriction("impl", context, &impl_restriction.kind)
+}
+
+fn format_restriction(
+    kw: &'static str,
+    context: &RewriteContext<'_>,
+    restriction: &RestrictionKind,
+) -> String {
+    match restriction {
+        RestrictionKind::Unrestricted => String::new(),
+        RestrictionKind::Restricted {
+            ref path,
+            id: _,
+            shorthand,
+        } => {
+            let Path { ref segments, .. } = **path;
+            let mut segments_iter = segments.iter().map(|seg| rewrite_ident(context, seg.ident));
+            if path.is_global() && segments_iter.next().is_none() {
+                panic!("non-global path in {kw}(restricted)?");
+            }
+            // FIXME use `segments_iter.intersperse("::").collect::<String>()` once
+            // `#![feature(iter_intersperse)]` is re-stabilized.
+            let path = itertools::join(segments_iter, "::");
+            let in_str = if *shorthand { "" } else { "in " };
+
+            format!("{kw}({in_str}{path}) ")
+        }
+    }
+}
+
 #[inline]
 pub(crate) fn format_coro(coroutine_kind: &ast::CoroutineKind) -> &'static str {
     match coroutine_kind {

src/tools/rustfmt/tests/source/impl-restriction.rs

@@ -0,0 +1,41 @@
+#![feature(impl_restriction)]
+
+pub
+impl(crate)
+trait Foo {}
+
+pub impl
+( in
+crate )
+trait
+Bar
+{}
+
+pub
+impl ( in foo
+::
+bar )
+trait Baz {}
+
+pub
+const
+impl
+(self)
+trait QuxConst {}
+
+pub 
+auto impl(
+super
+)
+trait QuxAuto {}
+
+pub 
+unsafe impl
+(in crate)
+trait QuxUnsafe {}
+
+pub const 
+unsafe impl
+(in super
+::foo)
+trait QuxConstUnsafe {}

src/tools/rustfmt/tests/target/impl-restriction.rs

@@ -0,0 +1,15 @@
+#![feature(impl_restriction)]
+
+pub impl(crate) trait Foo {}
+
+pub impl(in crate) trait Bar {}
+
+pub impl(in foo::bar) trait Baz {}
+
+pub const impl(self) trait QuxConst {}
+
+pub auto impl(super) trait QuxAuto {}
+
+pub unsafe impl(in crate) trait QuxUnsafe {}
+
+pub const unsafe impl(in super::foo) trait QuxConstUnsafe {}