src/tools/clippy/tests/ui/auxiliary/proc_macro_suspicious_else_formatting.rs

   1 // compile-flags: --emit=link
   2 // no-prefer-dynamic
   3
   4 #![crate_type = "proc-macro"]
   5
   6 extern crate proc_macro;
   7 use proc_macro::{token_stream, Delimiter, Group, Ident, Span, TokenStream, TokenTree};
   8
   9 fn read_ident(iter: &mut token_stream::IntoIter) -> Ident {
  10     match iter.next() {
  11         Some(TokenTree::Ident(i)) => i,
  12         _ => panic!("expected ident"),
  13     }
  14 }
  15
  16 #[proc_macro_derive(DeriveBadSpan)]
  17 pub fn derive_bad_span(input: TokenStream) -> TokenStream {
  18     let mut input = input.into_iter();
  19     assert_eq!(read_ident(&mut input).to_string(), "struct");
  20     let ident = read_ident(&mut input);
  21     let mut tys = match input.next() {
  22         Some(TokenTree::Group(g)) if g.delimiter() == Delimiter::Parenthesis => g.stream().into_iter(),
  23         _ => panic!(),
  24     };
  25     let field1 = read_ident(&mut tys);
  26     tys.next();
  27     let field2 = read_ident(&mut tys);
  28
  29     <TokenStream as FromIterator<TokenTree>>::from_iter(
  30         [
  31             Ident::new("impl", Span::call_site()).into(),
  32             ident.into(),
  33             Group::new(
  34                 Delimiter::Brace,
  35                 <TokenStream as FromIterator<TokenTree>>::from_iter(
  36                     [
  37                         Ident::new("fn", Span::call_site()).into(),
  38                         Ident::new("_foo", Span::call_site()).into(),
  39                         Group::new(Delimiter::Parenthesis, TokenStream::new()).into(),
  40                         Group::new(
  41                             Delimiter::Brace,
  42                             <TokenStream as FromIterator<TokenTree>>::from_iter(
  43                                 [
  44                                     Ident::new("if", field1.span()).into(),
  45                                     Ident::new("true", field1.span()).into(),
  46                                     {
  47                                         let mut group = Group::new(Delimiter::Brace, TokenStream::new());
  48                                         group.set_span(field1.span());
  49                                         group.into()
  50                                     },
  51                                     Ident::new("if", field2.span()).into(),
  52                                     Ident::new("true", field2.span()).into(),
  53                                     {
  54                                         let mut group = Group::new(Delimiter::Brace, TokenStream::new());
  55                                         group.set_span(field2.span());
  56                                         group.into()
  57                                     },
  58                                 ]
  59                                 .iter()
  60                                 .cloned(),
  61                             ),
  62                         )
  63                         .into(),
  64                     ]
  65                     .iter()
  66                     .cloned(),
  67                 ),
  68             )
  69             .into(),
  70         ]
  71         .iter()
  72         .cloned(),
  73     )
  74 }