Allow giving a name for the context and applicability.

Build the suggestion tokens while parsing rather than all at once at the end.

Author: Jarcho

clippy_macros/src/expr_sugg.rs

@@ -1,5 +1,5 @@
 use core::{cmp, fmt::Write, mem};
-use proc_macro2::{Delimiter, Ident, Spacing, Span, TokenStream, TokenTree as TT};
+use proc_macro2::{Delimiter, Group, Ident, Spacing, Span, TokenStream, TokenTree as TT};
 use quote::{quote, quote_spanned, ToTokens};
 
 macro_rules! expr_position {
@@ -83,11 +83,6 @@ expr_precedence! {
     Prefix => Unary,
     Postfix => Call,
 }
-impl Default for ExprPrecedence {
-    fn default() -> Self {
-        Self::Postfix
-    }
-}
 
 macro_rules! prec {
     ($name:ident) => {{
@@ -172,30 +167,6 @@ impl Default for State {
 #[allow(clippy::enum_glob_use)]
 use State::*;
 
-enum Output {
-    String(String),
-    Snip(Snip),
-    Mut(TokenStream),
-}
-impl ToTokens for Output {
-    fn to_tokens(&self, tokens: &mut TokenStream) {
-        match self {
-            Self::String(s) => tokens.extend(quote!(sugg.push_str(#s);)),
-            Self::Snip(s) => {
-                let stream = &s.stream;
-                let position = s.position;
-                tokens.extend(quote!(sugg.push_str(&clippy_utils::_internal::snip(cx, #stream, #position, &mut app));));
-            },
-            Self::Mut(s) => tokens.extend(quote! {
-                match #s {
-                    rustc_ast::Mutability::Mut => sugg.push_str("mut "),
-                    rustc_ast::Mutability::Not => (),
-                }
-            }),
-        }
-    }
-}
-
 enum Error {
     UnexpectedToken(Span),
     UnknownCommand(Span),
@@ -215,28 +186,42 @@ struct Snip {
     position: ExprPosition,
 }
 
-#[derive(Default)]
 struct ExprParser {
     state: State,
     next_string: String,
     precedence: ExprPrecedence,
-    result: Vec<Output>,
+    result: TokenStream,
 }
 impl ExprParser {
+    #[allow(clippy::needless_pass_by_value)]
+    fn new(cx_tokens: TT, app_tokens: TT) -> Self {
+        Self {
+            state: State::default(),
+            next_string: String::new(),
+            precedence: ExprPrecedence::Postfix,
+            result: quote! {
+                let cx: &rustc_lint::LateContext<'_> = #cx_tokens;
+                let app: &mut rustc_errors::Applicability = #app_tokens;
+                let mut sugg = String::new();
+            },
+        }
+    }
+
     fn push_str(&mut self) {
         if !self.next_string.is_empty() {
-            self.result.push(Output::String(self.next_string.clone()));
+            let s = &self.next_string;
+            self.result.extend(quote!(sugg.push_str(#s);));
             self.next_string.clear();
         }
     }
 
     fn push_snip(&mut self, kind: ExprKind, position: ExprPosition) {
         if let ExprKind::Snip(s) = kind {
             debug_assert!(self.next_string.is_empty());
-            self.result.push(Output::Snip(Snip {
-                position: cmp::max(s.position, position),
-                ..s
-            }));
+            let stream = s.stream;
+            let position = cmp::max(s.position, position);
+            self.result
+                .extend(quote!(sugg.push_str(&clippy_utils::_internal::snip(cx, #stream, #position, app));));
         }
     }
 
@@ -254,8 +239,7 @@ impl ExprParser {
     }
 
     #[allow(clippy::too_many_lines)]
-    fn parse(&mut self, input: TokenStream) -> Result<(), Error> {
-        let mut iter = input.into_iter();
+    fn parse(&mut self, mut iter: <TokenStream as IntoIterator>::IntoIter) -> Result<(), Error> {
         while let Some(tt) = iter.next() {
             self.state = match (tt, mem::take(&mut self.state)) {
                 (TT::Punct(p), state @ (Start | Prefix | PrefixRef | BinOp(_) | PartialBinOp(..)))
@@ -293,7 +277,14 @@ impl ExprParser {
                                 match iter.next().unwrap() {
                                     TT::Group(args) if args.delimiter() == Delimiter::Parenthesis => {
                                         self.push_str();
-                                        self.result.push(Output::Mut(args.stream()));
+                                        let stream = args.stream();
+                                        self.result.extend(quote! {
+                                            let mutability: rustc_ast::Mutability = #stream;
+                                            match mutability {
+                                                rustc_ast::Mutability::Mut => sugg.push_str("mut "),
+                                                rustc_ast::Mutability::Not => (),
+                                            }
+                                        });
                                         Prefix
                                     },
                                     tt => return Err(Error::UnexpectedToken(tt.span())),
@@ -313,7 +304,7 @@ impl ExprParser {
                         let precedence = self.precedence;
                         self.next_string.push('[');
                         self.state = Start;
-                        self.parse(g.stream())?;
+                        self.parse(g.stream().into_iter())?;
                         self.next_string.push(']');
                         self.precedence = precedence;
                         Expr(ExprKind::Normal)
@@ -527,7 +518,7 @@ impl ExprParser {
                     let precedence = self.precedence;
                     self.next_string.push('(');
                     self.state = Start;
-                    self.parse(g.stream())?;
+                    self.parse(g.stream().into_iter())?;
                     self.next_string.push(')');
                     self.precedence = precedence;
                     Expr(ExprKind::Normal)
@@ -537,6 +528,7 @@ impl ExprParser {
             };
         }
 
+        self.push_str();
         match mem::take(&mut self.state) {
             Start => Ok(()),
             Expr(kind) => {
@@ -547,19 +539,14 @@ impl ExprParser {
         }
     }
 
-    fn into_stream(mut self) -> TokenStream {
-        self.push_str();
-        let output = self.result.iter();
+    fn into_stream(self) -> TokenStream {
+        let mut result = self.result;
         let precedence = self.precedence;
-
-        quote! {{
-            let mut sugg = String::new();
-            #(#output)*
-            clippy_utils::_internal::Sugg {
-                sugg,
-                precedence: #precedence,
-            }
-        }}
+        result.extend(quote! { clippy_utils::_internal::Sugg {
+            sugg,
+            precedence: #precedence,
+        }});
+        TT::Group(Group::new(Delimiter::Brace, result)).into()
     }
 }
 
@@ -568,8 +555,26 @@ fn make_error(msg: &str, span: Span) -> TokenStream {
 }
 
 pub fn expr_sugg(input: TokenStream) -> TokenStream {
-    let mut parser = ExprParser::default();
-    match parser.parse(input) {
+    let mut iter = input.into_iter();
+    let cx = match iter.next() {
+        Some(TT::Ident(cx)) => TT::Ident(cx),
+        _ => panic!(),
+    };
+    match iter.next() {
+        Some(TT::Punct(p)) if p.as_char() == ',' => (),
+        _ => panic!(),
+    };
+    let app = match iter.next() {
+        Some(TT::Ident(app)) => TT::Ident(app),
+        _ => panic!(),
+    };
+    match iter.next() {
+        Some(TT::Punct(p)) if p.as_char() == ',' => (),
+        _ => panic!(),
+    };
+
+    let mut parser = ExprParser::new(cx, app);
+    match parser.parse(iter) {
         Ok(()) => parser.into_stream(),
         Err(Error::UnexpectedToken(span)) => make_error("unexpected token", span),
         Err(Error::UnexpectedMut(span)) => make_error("unexpected `mut` command", span),

clippy_macros/tests/expr_sugg.rs

@@ -4,15 +4,18 @@ extern crate clippy_macros;
 extern crate rustc_ast;
 extern crate rustc_errors;
 
-struct LateContext<'a>(&'a ());
+mod rustc_lint {
+    pub struct LateContext<'a>(pub &'a ());
+}
+
 struct Expr<'a>(&'a str, ExprPosition);
 mod clippy_utils {
     pub(crate) mod _internal {
         extern crate clippy_utils;
         pub(crate) use clippy_utils::_internal::{ExprPosition, Sugg};
 
         pub(crate) fn snip(
-            _: &crate::LateContext<'_>,
+            _: &crate::rustc_lint::LateContext<'_>,
             e: &crate::Expr<'_>,
             position: ExprPosition,
             _app: &mut rustc_errors::Applicability,
@@ -32,41 +35,45 @@ use rustc_ast::Mutability;
 
 #[test]
 fn test() {
-    let cx = &LateContext(&());
+    let cx = &rustc_lint::LateContext(&());
     let mut app = rustc_errors::Applicability::MachineApplicable;
+    let app = &mut app;
 
     let e = &Expr("&foo", ExprPosition::Prefix);
-    assert_eq!(expr_sugg!($snip(e).foo).into_string(), "(&foo).foo");
+    assert_eq!(expr_sugg!(cx, app, $snip(e).foo).into_string(), "(&foo).foo");
 
     let mutability = Mutability::Not;
-    assert_eq!(expr_sugg!(&$mut(mutability) foo).into_string(), "&foo");
+    assert_eq!(expr_sugg!(cx, app, &$mut(mutability) foo).into_string(), "&foo");
 
     let mutability = Mutability::Mut;
-    assert_eq!(expr_sugg!(&$mut(mutability) foo).into_string(), "&mut foo");
+    assert_eq!(expr_sugg!(cx, app, &$mut(mutability) foo).into_string(), "&mut foo");
 
     let e = &Expr("x + y", ExprPosition::AddLhs);
-    assert_eq!(expr_sugg!($snip(e) + 20).into_string(), "x + y + 20");
-    assert_eq!(expr_sugg!(20 + $snip(e)).into_string(), "20 + (x + y)");
+    assert_eq!(expr_sugg!(cx, app, $snip(e) + 20).into_string(), "x + y + 20");
+    assert_eq!(expr_sugg!(cx, app, 20 + $snip(e)).into_string(), "20 + (x + y)");
 
     let e = &Expr("foo", ExprPosition::Postfix);
-    assert_eq!(expr_sugg!(&$snip(e)).for_position(ExprPosition::Postfix), "(&foo)");
+    assert_eq!(
+        expr_sugg!(cx, app, &$snip(e)).for_position(ExprPosition::Postfix),
+        "(&foo)"
+    );
 
     let e = &Expr("x * y", ExprPosition::MulLhs);
     assert_eq!(
-        expr_sugg!(x + $snip(e)).for_position(ExprPosition::MulLhs),
+        expr_sugg!(cx, app, x + $snip(e)).for_position(ExprPosition::MulLhs),
         "(x + x * y)"
     );
 
     assert_eq!(
-        expr_sugg!($snip(e) != $snip(e)).for_position(ExprPosition::BitAndLhs),
+        expr_sugg!(cx, app, $snip(e) != $snip(e)).for_position(ExprPosition::BitAndLhs),
         "(x * y != x * y)"
     );
     assert_eq!(
-        expr_sugg!((x..=$snip(e)).start).for_position(ExprPosition::Prefix),
+        expr_sugg!(cx, app, (x..=$snip(e)).start).for_position(ExprPosition::Prefix),
         "(x..=x * y).start"
     );
     assert_eq!(
-        expr_sugg!(x&&&$snip(e)).for_position(ExprPosition::Let),
+        expr_sugg!(cx, app, x&&&$snip(e)).for_position(ExprPosition::Let),
         "(x && &(x * y))"
     );
 }