Improve token stream pretty printing.

Specifically:
- No space before or after `::`, e.g. `a::b` instead of `a :: b`.
- No space between `!` and `(`, e.g. `foo!()` instead of `foo! ()`.
- No space between `!` and `[`, e.g. `#![...]` instead of `#! [...]`.
- No space before `:`, e.g. `a: u32` instead of `a : u32`.
- No space before `;`, e.g. `struct A;` instead of `struct A ;`.

Author: nnethercote

compiler/rustc_ast_pretty/src/pprust/state.rs

@@ -146,20 +146,29 @@ pub fn print_crate<'a>(
 /// and also addresses some specific regressions described in #63896 and #73345.
 fn tt_prepend_space(tt: &TokenTree, prev: &TokenTree) -> bool {
     if let TokenTree::Token(token) = prev {
-        if matches!(token.kind, token::Dot | token::Dollar) {
+        // No space after these tokens, e.g. `x.y`, `$e`, `a::b`
+        // (The carets point to `prev`)        ^     ^      ^^
+        if matches!(token.kind, token::Dot | token::Dollar | token::ModSep) {
             return false;
         }
         if let token::DocComment(comment_kind, ..) = token.kind {
             return comment_kind != CommentKind::Line;
         }
     }
     match tt {
-        TokenTree::Token(token) => !matches!(token.kind, token::Comma | token::Not | token::Dot),
+        // No space before these tokens, e.g. `x,`, `m!`, `x.y`, `a::b`, `s;`, `x:`
+        // (The carets point to `token`)        ^     ^     ^      ^^     ^     ^
+        TokenTree::Token(token) => !matches!(
+            token.kind,
+            token::Comma | token::Not | token::Dot | token::ModSep | token::Semi | token::Colon
+        ),
+        // No space before parentheses if preceded by these tokens, e.g. `foo(...)`, `foo!(...).
         TokenTree::Delimited(_, Delimiter::Parenthesis, _) => {
-            !matches!(prev, TokenTree::Token(Token { kind: token::Ident(..), .. }))
+            !matches!(prev, TokenTree::Token(Token { kind: token::Ident(..) | token::Not, .. }))
         }
+        // No space before brackets if preceded by these tokens, e.g. e.g. `#[...]`, `#![...]`.
         TokenTree::Delimited(_, Delimiter::Bracket, _) => {
-            !matches!(prev, TokenTree::Token(Token { kind: token::Pound, .. }))
+            !matches!(prev, TokenTree::Token(Token { kind: token::Pound | token::Not, .. }))
         }
         TokenTree::Delimited(..) => true,
     }

src/test/pretty/ast-stmt-expr-attr.rs

@@ -114,11 +114,11 @@ fn syntax() {
     let _ = #[attr] continue;
     let _ = #[attr] return;
     let _ = #[attr] foo!();
-    let _ = #[attr] foo!(#! [attr]);
+    let _ = #[attr] foo!(#![attr]);
     let _ = #[attr] foo![];
-    let _ = #[attr] foo![#! [attr]];
+    let _ = #[attr] foo![#![attr]];
     let _ = #[attr] foo! {};
-    let _ = #[attr] foo! { #! [attr] };
+    let _ = #[attr] foo! { #![attr] };
     let _ = #[attr] Foo { bar: baz };
     let _ = #[attr] Foo { ..foo };
     let _ = #[attr] Foo { bar: baz, ..foo };

src/test/pretty/cast-lt.pp

@@ -8,6 +8,6 @@
 // pretty-mode:expanded
 // pp-exact:cast-lt.pp
 
-macro_rules! negative { ($e : expr) => { $e < 0 } }
+macro_rules! negative { ($e: expr) => { $e < 0 } }
 
 fn main() { (1 as i32) < 0; }

src/test/pretty/delimited-token-groups.rs

@@ -2,14 +2,14 @@
 
 #![feature(rustc_attrs)]
 
-macro_rules! mac { ($($tt : tt) *) => () }
+macro_rules! mac { ($($tt: tt) *) => () }
 
 mac! {
-    struct S { field1 : u8, field2 : u16, } impl Clone for S
+    struct S { field1: u8, field2: u16, } impl Clone for S
     {
         fn clone() -> S
         {
-            panic! () ;
+            panic!();
 
         }
     }

src/test/pretty/macro.rs

@@ -2,6 +2,6 @@
 
 #![feature(decl_macro)]
 
-pub(crate) macro mac { ($arg : expr) => { $arg + $arg } }
+pub(crate) macro mac { ($arg: expr) => { $arg + $arg } }
 
 fn main() {}

src/test/pretty/macro_rules.rs

@@ -1,19 +1,19 @@
 // pp-exact
 
-macro_rules! brace { () => {} ; }
+macro_rules! brace { () => {}; }
 
-macro_rules! bracket[() => {} ;];
+macro_rules! bracket[() => {};];
 
-macro_rules! paren(() => {} ;);
+macro_rules! paren(() => {};);
 
 macro_rules! matcher_brackets {
-    (paren) => {} ; (bracket) => {} ; (brace) => {} ;
+    (paren) => {}; (bracket) => {}; (brace) => {};
 }
 
 macro_rules! all_fragments {
-    ($b : block, $e : expr, $i : ident, $it : item, $l : lifetime, $lit :
-    literal, $m : meta, $p : pat, $pth : path, $s : stmt, $tt : tt, $ty : ty,
-    $vis : vis) => {} ;
+    ($b: block, $e: expr, $i: ident, $it: item, $l: lifetime, $lit: literal,
+    $m: meta, $p: pat, $pth: path, $s: stmt, $tt: tt, $ty: ty, $vis: vis) =>
+    {};
 }
 
 fn main() {}

src/test/pretty/stmt_expr_attributes.rs

@@ -114,7 +114,7 @@ fn _8() {
 }
 
 fn _9() {
-    macro_rules! stmt_mac { () => { let _ = () ; } }
+    macro_rules! stmt_mac { () => { let _ = (); } }
 
     #[rustc_dummy]
     stmt_mac!();

src/test/run-make/rustc-macro-dep-files/foo.rs

@@ -7,6 +7,6 @@ use proc_macro::TokenStream;
 #[proc_macro_derive(A)]
 pub fn derive(input: TokenStream) -> TokenStream {
     let input = input.to_string();
-    assert!(input.contains("struct A ;"));
+    assert!(input.contains("struct A;"));
     "struct B;".parse().unwrap()
 }

src/test/ui/async-await/issues/issue-60674.stdout

@@ -1,3 +1,3 @@
-async fn f(mut x : u8) {}
-async fn g((mut x, y, mut z) : (u8, u8, u8)) {}
-async fn g(mut x : u8, (a, mut b, c) : (u8, u8, u8), y : u8) {}
+async fn f(mut x: u8) {}
+async fn g((mut x, y, mut z): (u8, u8, u8)) {}
+async fn g(mut x: u8, (a, mut b, c): (u8, u8, u8), y: u8) {}

src/test/ui/hygiene/unpretty-debug.stdout

@@ -8,7 +8,7 @@
 #![feature /* 0#0 */(no_core)]
 #![no_core /* 0#0 */]
 
-macro_rules! foo /* 0#0 */ { ($x : ident) => { y + $x } }
+macro_rules! foo /* 0#0 */ { ($x: ident) => { y + $x } }
 
 fn bar /* 0#0 */() {
     let x /* 0#0 */ = 1;