Discard paren attrs in unparenthesize test

Author: dtolnay

tests/common/visit.rs

@@ -3,9 +3,23 @@ use std::mem;
 use syn::visit_mut::{self, VisitMut};
 use syn::{Expr, File, Generics, LifetimeParam, MacroDelimiter, Stmt, StmtMacro, TypeParam};
 
-pub struct FlattenParens;
+pub struct FlattenParens {
+    discard_paren_attrs: bool,
+}
 
 impl FlattenParens {
+    pub fn discard_attrs() -> Self {
+        FlattenParens {
+            discard_paren_attrs: true,
+        }
+    }
+
+    pub fn combine_attrs() -> Self {
+        FlattenParens {
+            discard_paren_attrs: false,
+        }
+    }
+
     pub fn visit_token_stream_mut(tokens: &mut TokenStream) {
         *tokens = mem::take(tokens)
             .into_iter()
@@ -32,7 +46,7 @@ impl VisitMut for FlattenParens {
         while let Expr::Paren(paren) = e {
             let paren_attrs = mem::take(&mut paren.attrs);
             *e = mem::replace(&mut *paren.expr, Expr::PLACEHOLDER);
-            if !paren_attrs.is_empty() {
+            if !paren_attrs.is_empty() && !self.discard_paren_attrs {
                 let nested_attrs = match e {
                     Expr::Assign(e) => &mut e.attrs,
                     Expr::Binary(e) => &mut e.attrs,

tests/test_expr.rs

@@ -838,7 +838,7 @@ fn test_fixup() {
         let original: Expr = syn::parse2(tokens).unwrap();
 
         let mut flat = original.clone();
-        FlattenParens.visit_expr_mut(&mut flat);
+        FlattenParens::combine_attrs().visit_expr_mut(&mut flat);
         let reconstructed: Expr = match syn::parse2(flat.to_token_stream()) {
             Ok(reconstructed) => reconstructed,
             Err(err) => panic!("failed to parse `{}`: {}", flat.to_token_stream(), err),
@@ -1615,7 +1615,7 @@ fn test_permutations() -> ExitCode {
             );
         };
         AsIfPrinted.visit_expr_mut(&mut original);
-        FlattenParens.visit_expr_mut(&mut parsed);
+        FlattenParens::combine_attrs().visit_expr_mut(&mut parsed);
         if original != parsed {
             fail!(
                 "before: {}\n{:#?}\nafter: {}\n{:#?}",
@@ -1629,7 +1629,7 @@ fn test_permutations() -> ExitCode {
         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);
+                FlattenParens::combine_attrs().visit_expr_mut(&mut parsed2);
                 if original == parsed2 {
                     fail!("redundant parens: {}", tokens);
                 }

tests/test_unparenthesize.rs

@@ -43,10 +43,10 @@ fn test(path: &Path, failed: &AtomicUsize) {
 
     match panic::catch_unwind(|| -> syn::Result<()> {
         let mut before = syn::parse_file(&content)?;
-        FlattenParens.visit_file_mut(&mut before);
+        FlattenParens::discard_attrs().visit_file_mut(&mut before);
         let printed = before.to_token_stream();
         let mut after = syn::parse2::<syn::File>(printed.clone())?;
-        FlattenParens.visit_file_mut(&mut after);
+        FlattenParens::discard_attrs().visit_file_mut(&mut after);
         // Normalize features that we expect Syn not to print.
         AsIfPrinted.visit_file_mut(&mut before);
         if before != after {