refactor: update ast::Mac tokenstream detection

Author: calebcartwright

rustfmt-core/rustfmt-lib/src/attr.rs

@@ -34,7 +34,7 @@ pub(crate) fn get_span_without_attrs(stmt: &ast::Stmt) -> Span {
         ast::StmtKind::Expr(ref expr) | ast::StmtKind::Semi(ref expr) => expr.span,
         ast::StmtKind::Mac(ref mac) => {
             let (ref mac, _, _) = **mac;
-            mac.span
+            mac.span()
         }
     }
 }

rustfmt-core/rustfmt-lib/src/expr.rs

@@ -1336,8 +1336,8 @@ pub(crate) fn can_be_overflowed_expr(
                 || (context.use_block_indent() && args_len == 1)
         }
         ast::ExprKind::Mac(ref mac) => {
-            match (mac.delim, context.config.overflow_delimited_expr()) {
-                (ast::MacDelimiter::Bracket, true) | (ast::MacDelimiter::Brace, true) => true,
+            match (syntax::ast::MacDelimiter::from_token(mac.args.delim()), context.config.overflow_delimited_expr()) {
+                (Some(ast::MacDelimiter::Bracket), true) | (Some(ast::MacDelimiter::Brace), true) => true,
                 _ => context.use_block_indent() && args_len == 1,
             }
         }

rustfmt-core/rustfmt-lib/src/macros.rs

@@ -262,8 +262,13 @@ fn rewrite_macro_inner(
         original_style
     };
 
-    let ts: TokenStream = mac.stream();
-    let has_comment = contains_comment(context.snippet(mac.span));
+    let ts: TokenStream = match *mac.args {
+        ast::MacArgs::Empty => TokenStream::default(),
+        ast::MacArgs::Delimited(_, _, token_stream) => token_stream,
+        ast::MacArgs::Eq(_, token_stream) => token_stream,
+    };
+
+    let has_comment = contains_comment(context.snippet(mac.span()));
     if ts.is_empty() && !has_comment {
         return match style {
             DelimToken::Paren if position == MacroPosition::Item => {
@@ -297,7 +302,7 @@ fn rewrite_macro_inner(
             } else if let Some(arg) = parse_macro_arg(&mut parser) {
                 arg_vec.push(arg);
             } else {
-                return return_macro_parse_failure_fallback(context, shape.indent, mac.span);
+                return return_macro_parse_failure_fallback(context, shape.indent, mac.span());
             }
 
             match parser.token.kind {
@@ -321,16 +326,16 @@ fn rewrite_macro_inner(
                                     return return_macro_parse_failure_fallback(
                                         context,
                                         shape.indent,
-                                        mac.span,
+                                        mac.span(),
                                     );
                                 }
                             }
                         }
                     }
-                    return return_macro_parse_failure_fallback(context, shape.indent, mac.span);
+                    return return_macro_parse_failure_fallback(context, shape.indent, mac.span());
                 }
                 _ if arg_vec.last().map_or(false, MacroArg::is_item) => continue,
-                _ => return return_macro_parse_failure_fallback(context, shape.indent, mac.span),
+                _ => return return_macro_parse_failure_fallback(context, shape.indent, mac.span()),
             }
 
             parser.bump();
@@ -350,7 +355,7 @@ fn rewrite_macro_inner(
             shape,
             style,
             position,
-            mac.span,
+            mac.span(),
         );
     }
 
@@ -367,7 +372,7 @@ fn rewrite_macro_inner(
                     &macro_name,
                     arg_vec.iter(),
                     shape,
-                    mac.span,
+                    mac.span(),
                     context.config.width_heuristics().fn_call_width,
                     if trailing_comma {
                         Some(SeparatorTactic::Always)
@@ -404,7 +409,7 @@ fn rewrite_macro_inner(
                 let rewrite = rewrite_array(
                     macro_name,
                     arg_vec.iter(),
-                    mac.span,
+                    mac.span(),
                     context,
                     shape,
                     force_trailing_comma,
@@ -422,7 +427,7 @@ fn rewrite_macro_inner(
             // For macro invocations with braces, always put a space between
             // the `macro_name!` and `{ /* macro_body */ }` but skip modifying
             // anything in between the braces (for now).
-            let snippet = context.snippet(mac.span).trim_start_matches(|c| c != '{');
+            let snippet = context.snippet(mac.span()).trim_start_matches(|c| c != '{');
             match trim_left_preserve_layout(snippet, shape.indent, &context.config) {
                 Some(macro_body) => Some(format!("{} {}", macro_name, macro_body)),
                 None => Some(format!("{} {}", macro_name, snippet)),
@@ -486,8 +491,12 @@ pub(crate) fn rewrite_macro_def(
     if snippet.as_ref().map_or(true, |s| s.ends_with(';')) {
         return snippet;
     }
-
-    let mut parser = MacroParser::new(def.stream().into_trees());
+    let ts: TokenStream = match *def.body {
+        ast::MacArgs::Empty => TokenStream::default(),
+        ast::MacArgs::Delimited(_, _, token_stream) => token_stream,
+        ast::MacArgs::Eq(_, token_stream) => token_stream,
+    };
+    let mut parser = MacroParser::new(ts.into_trees());
     let parsed_def = match parser.parse() {
         Some(def) => def,
         None => return snippet,
@@ -1192,17 +1201,21 @@ pub(crate) fn convert_try_mac(mac: &ast::Mac, context: &RewriteContext<'_>) -> O
     // https://github.com/rust-lang/rust/pull/62672
     let path = &pprust::path_to_string(&mac.path);
     if path == "try" || path == "r#try" {
-        let ts: TokenStream = mac.tts.clone();
+        let ts: TokenStream = match *mac.args {
+            ast::MacArgs::Empty => TokenStream::default(),
+            ast::MacArgs::Delimited(_, _, token_stream) => token_stream,
+            ast::MacArgs::Eq(_, token_stream) => token_stream,
+        };
         let mut parser = new_parser_from_tts(context.parse_sess.inner(), ts.trees().collect());
 
         let mut kind = parser.parse_expr().ok()?;
         // take the end pos of mac so that the Try expression includes the closing parenthesis of
         // the try! macro
-        kind.span = mk_sp(kind.span.lo(), mac.span.hi());
+        kind.span = mk_sp(kind.span.lo(), mac.span().hi());
         Some(ast::Expr {
             id: ast::NodeId::root(), // dummy value
             kind: ast::ExprKind::Try(kind),
-            span: mac.span, // incorrect span, but shouldn't matter too much
+            span: mac.span(), // incorrect span, but shouldn't matter too much
             attrs: ast::AttrVec::new(),
         })
     } else {
@@ -1211,7 +1224,7 @@ pub(crate) fn convert_try_mac(mac: &ast::Mac, context: &RewriteContext<'_>) -> O
 }
 
 fn macro_style(mac: &ast::Mac, context: &RewriteContext<'_>) -> DelimToken {
-    let snippet = context.snippet(mac.span);
+    let snippet = context.snippet(mac.span());
     let paren_pos = snippet.find_uncommented("(").unwrap_or(usize::max_value());
     let bracket_pos = snippet.find_uncommented("[").unwrap_or(usize::max_value());
     let brace_pos = snippet.find_uncommented("{").unwrap_or(usize::max_value());

rustfmt-core/rustfmt-lib/src/syntux/parser.rs

@@ -283,9 +283,14 @@ impl<'a> Parser<'a> {
         mac: &'a ast::Mac,
         base_dir: &Directory,
     ) -> Result<Vec<ast::Item>, &'static str> {
+        let token_stream: syntax::tokenstream::TokenStream = match *mac.args {
+            ast::MacArgs::Empty => syntax::tokenstream::TokenStream::default(),
+            ast::MacArgs::Delimited(_, _, token_stream) => token_stream,
+            ast::MacArgs::Eq(_, token_stream) => token_stream,
+        };
         let mut parser = rustc_parse::stream_to_parser_with_base_dir(
             sess.inner(),
-            mac.tts.clone(),
+            token_stream.clone(),
             base_dir.to_syntax_directory(),
         );
 

rustfmt-core/rustfmt-lib/src/visitor.rs

@@ -656,12 +656,12 @@ impl<'b, 'a: 'b> FmtVisitor<'a> {
     }
 
     fn visit_mac(&mut self, mac: &ast::Mac, ident: Option<ast::Ident>, pos: MacroPosition) {
-        skip_out_of_file_lines_range_visitor!(self, mac.span);
+        skip_out_of_file_lines_range_visitor!(self, mac.span());
 
         // 1 = ;
         let shape = self.shape().saturating_sub_width(1);
         let rewrite = self.with_context(|ctx| rewrite_macro(mac, ident, ctx, shape, pos));
-        self.push_rewrite(mac.span, rewrite);
+        self.push_rewrite(mac.span(), rewrite);
     }
 
     pub(crate) fn push_str(&mut self, s: &str) {