Change:
proc-macro derive panicked All of the 62 regressions are due to old versions of having an assert expecting instead of . So this is again a consequence of whitespace changes in pretty-printing (). I think we should be able to fix this by special casing the comma token during token stream pretty-printing and not printing the space before it.
Fixed in
Just FYI, we discussed this in the meeting. We felt like the action here was appropriate -- while in general we do not guarantee stability of pretty printing, it makes sense to be judicious, and in this particular case not having a leading space before just looks better anyway.

Discussion:
printer.s.eof() } <ins> // This makes comma-separated lists look slightly nicer, // and also addresses a specific regression described in issue #63896. fn tt_prepend_space(tt: &TokenTree) -> bool { match tt { TokenTree::Token(token) => match token.kind { token::Comma => false, _ => true, } _ => true, } } </ins> fn binop_to_string(op: BinOpToken) -> &'static str { match op { token::Plus     => "+",

fn print_tts(&mut self, tts: tokenstream::TokenStream, convert_dollar_crate: bool) { for (i, tt) in tts.into_trees().enumerate() { <del> if i != 0 { </del> <ins> if i != 0 && tt_prepend_space(&tt) { </ins> self.space(); } self.print_tt(tt, convert_dollar_crate);

#![feature(rustc_attrs)] fn main() { <del> #![rustc_dummy("hi" , 1 , 2 , 1.012 , pi = 3.14 , bye , name ("John"))] </del> <ins> #![rustc_dummy("hi", 1, 2, 1.012, pi = 3.14, bye, name ("John"))] </ins> #[rustc_dummy = 8] fn f() { } <del> #[rustc_dummy(1 , 2 , 3)] </del> <ins> #[rustc_dummy(1, 2, 3)] </ins> fn g() { } }

'u{2004}', 'u{2005}', 'u{2006}', 'u{2007}', 'u{2008}', 'u{2009}', 'u{200A}', 'u{2028}', 'u{2029}', 'u{202F}', 'u{205F}', 'u{3000}']; <del> for c in &chars { let ws = c.is_whitespace(); println!("{} {}" , c , ws); } </del> <ins> for c in &chars { let ws = c.is_whitespace(); println!("{} {}", c, ws); } </ins> }

macro_rules! mac { ($ ($ tt : tt) *) => () } mac! { <del> struct S { field1 : u8 , field2 : u16 , } impl Clone for S </del> <ins> struct S { field1 : u8, field2 : u16, } impl Clone for S </ins> { fn clone () -> S {

fn f<F>(f: F) where F: Fn(isize) { f(10) } <del> fn main() { f(|i| { assert_eq!(i , 10) }) } </del> <ins> fn main() { f(|i| { assert_eq!(i, 10) }) } </ins>

fn main() { let x = match { 5 } { 1 => 5, 2 => 6, _ => 7, }; <del> assert_eq!(x , 7); </del> <ins> assert_eq!(x, 7); </ins> }

} fn test_26444() { <del> assert_eq!("a , b , c , d , e", foo_26444!(a, b; c; d, e)); </del> <ins> assert_eq!("a, b, c, d, e", foo_26444!(a, b; c; d, e)); </ins> assert_eq!("f", foo_26444!(; f ;)); }

#[proc_macro_attribute] pub fn expect_print_stmt(attr: TokenStream, item: TokenStream) -> TokenStream { assert!(attr.to_string().is_empty()); <del> assert_eq!(item.to_string(), "println!("{}" , string);"); </del> <ins> assert_eq!(item.to_string(), "println!("{}", string);"); </ins> item }

#[proc_macro_attribute] pub fn expect_print_expr(attr: TokenStream, item: TokenStream) -> TokenStream { assert!(attr.to_string().is_empty()); <del> assert_eq!(item.to_string(), "println!("{}" , string)"); </del> <ins> assert_eq!(item.to_string(), "println!("{}", string)"); </ins> item }