Check for redundant parens in permutations test

tests/common/visit.rs

@@ -1,9 +1,32 @@
+use proc_macro2::{Delimiter, Group, TokenStream, TokenTree};
 use std::mem;
 use syn::visit_mut::{self, VisitMut};
 use syn::{Expr, File, Generics, LifetimeParam, MacroDelimiter, Stmt, StmtMacro, TypeParam};
 
 pub struct FlattenParens;
 
+impl FlattenParens {
+    pub fn visit_token_stream_mut(tokens: &mut TokenStream) {
+        *tokens = mem::take(tokens)
+            .into_iter()
+            .flat_map(|tt| {
+                if let TokenTree::Group(group) = tt {
+                    let delimiter = group.delimiter();
+                    let mut content = group.stream();
+                    Self::visit_token_stream_mut(&mut content);
+                    if let Delimiter::Parenthesis = delimiter {
+                        content
+                    } else {
+                        TokenStream::from(TokenTree::Group(Group::new(delimiter, content)))
+                    }
+                } else {
+                    TokenStream::from(tt)
+                }
+            })
+            .collect();
+    }
+}
+
 impl VisitMut for FlattenParens {
     fn visit_expr_mut(&mut self, e: &mut Expr) {
         while let Expr::Paren(paren) = e {

tests/test_expr.rs

@@ -1191,6 +1191,16 @@ fn test_permutations() -> ExitCode {
         if original != parsed {
             fail!("before: {}\nafter: {}", tokens, parsed.to_token_stream());
         }
+        let mut tokens_no_paren = tokens.clone();
+        FlattenParens::visit_token_stream_mut(&mut tokens_no_paren);
+        if tokens.to_string() != tokens_no_paren.to_string() {
+            if let Ok(mut parsed2) = syn::parse2::<Expr>(tokens_no_paren) {
+                FlattenParens.visit_expr_mut(&mut parsed2);
+                if original == parsed2 {
+                    fail!("redundant parens: {}", tokens);
+                }
+            }
+        }
     };
 
     iter(2, &mut assert);