vendor/syn/tests/test_stmt.rs

   1 #![allow(
   2     clippy::assertions_on_result_states,
   3     clippy::non_ascii_literal,
   4     clippy::uninlined_format_args
   5 )]
   6
   7 #[macro_use]
   8 mod macros;
   9
  10 use proc_macro2::{Delimiter, Group, Ident, Span, TokenStream, TokenTree};
  11 use quote::quote;
  12 use syn::Stmt;
  13
  14 #[test]
  15 fn test_raw_operator() {
  16     let stmt = syn::parse_str::<Stmt>("let _ = &raw const x;").unwrap();
  17
  18     snapshot!(stmt, @r###"
  19     Stmt::Local {
  20         pat: Pat::Wild,
  21         init: Some(LocalInit {
  22             expr: Expr::Verbatim(`& raw const x`),
  23         }),
  24     }
  25     "###);
  26 }
  27
  28 #[test]
  29 fn test_raw_variable() {
  30     let stmt = syn::parse_str::<Stmt>("let _ = &raw;").unwrap();
  31
  32     snapshot!(stmt, @r###"
  33     Stmt::Local {
  34         pat: Pat::Wild,
  35         init: Some(LocalInit {
  36             expr: Expr::Reference {
  37                 expr: Expr::Path {
  38                     path: Path {
  39                         segments: [
  40                             PathSegment {
  41                                 ident: "raw",
  42                             },
  43                         ],
  44                     },
  45                 },
  46             },
  47         }),
  48     }
  49     "###);
  50 }
  51
  52 #[test]
  53 fn test_raw_invalid() {
  54     assert!(syn::parse_str::<Stmt>("let _ = &raw x;").is_err());
  55 }
  56
  57 #[test]
  58 fn test_none_group() {
  59     // <Ø async fn f() {} Ø>
  60     let tokens = TokenStream::from_iter(vec![TokenTree::Group(Group::new(
  61         Delimiter::None,
  62         TokenStream::from_iter(vec![
  63             TokenTree::Ident(Ident::new("async", Span::call_site())),
  64             TokenTree::Ident(Ident::new("fn", Span::call_site())),
  65             TokenTree::Ident(Ident::new("f", Span::call_site())),
  66             TokenTree::Group(Group::new(Delimiter::Parenthesis, TokenStream::new())),
  67             TokenTree::Group(Group::new(Delimiter::Brace, TokenStream::new())),
  68         ]),
  69     ))]);
  70
  71     snapshot!(tokens as Stmt, @r###"
  72     Stmt::Item(Item::Fn {
  73         vis: Visibility::Inherited,
  74         sig: Signature {
  75             asyncness: Some,
  76             ident: "f",
  77             generics: Generics,
  78             output: ReturnType::Default,
  79         },
  80         block: Block,
  81     })
  82     "###);
  83 }
  84
  85 #[test]
  86 fn test_let_dot_dot() {
  87     let tokens = quote! {
  88         let .. = 10;
  89     };
  90
  91     snapshot!(tokens as Stmt, @r###"
  92     Stmt::Local {
  93         pat: Pat::Rest,
  94         init: Some(LocalInit {
  95             expr: Expr::Lit {
  96                 lit: 10,
  97             },
  98         }),
  99     }
 100     "###);
 101 }
 102
 103 #[test]
 104 fn test_let_else() {
 105     let tokens = quote! {
 106         let Some(x) = None else { return 0; };
 107     };
 108
 109     snapshot!(tokens as Stmt, @r###"
 110     Stmt::Local {
 111         pat: Pat::TupleStruct {
 112             path: Path {
 113                 segments: [
 114                     PathSegment {
 115                         ident: "Some",
 116                     },
 117                 ],
 118             },
 119             elems: [
 120                 Pat::Ident {
 121                     ident: "x",
 122                 },
 123             ],
 124         },
 125         init: Some(LocalInit {
 126             expr: Expr::Path {
 127                 path: Path {
 128                     segments: [
 129                         PathSegment {
 130                             ident: "None",
 131                         },
 132                     ],
 133                 },
 134             },
 135             diverge: Some(Expr::Block {
 136                 block: Block {
 137                     stmts: [
 138                         Stmt::Expr(
 139                             Expr::Return {
 140                                 expr: Some(Expr::Lit {
 141                                     lit: 0,
 142                                 }),
 143                             },
 144                             Some,
 145                         ),
 146                     ],
 147                 },
 148             }),
 149         }),
 150     }
 151     "###);
 152 }
 153
 154 #[test]
 155 fn test_macros() {
 156     let tokens = quote! {
 157         fn main() {
 158             macro_rules! mac {}
 159             thread_local! { static FOO }
 160             println!("");
 161             vec![]
 162         }
 163     };
 164
 165     snapshot!(tokens as Stmt, @r###"
 166     Stmt::Item(Item::Fn {
 167         vis: Visibility::Inherited,
 168         sig: Signature {
 169             ident: "main",
 170             generics: Generics,
 171             output: ReturnType::Default,
 172         },
 173         block: Block {
 174             stmts: [
 175                 Stmt::Item(Item::Macro {
 176                     ident: Some("mac"),
 177                     mac: Macro {
 178                         path: Path {
 179                             segments: [
 180                                 PathSegment {
 181                                     ident: "macro_rules",
 182                                 },
 183                             ],
 184                         },
 185                         delimiter: MacroDelimiter::Brace,
 186                         tokens: TokenStream(``),
 187                     },
 188                 }),
 189                 Stmt::Macro {
 190                     mac: Macro {
 191                         path: Path {
 192                             segments: [
 193                                 PathSegment {
 194                                     ident: "thread_local",
 195                                 },
 196                             ],
 197                         },
 198                         delimiter: MacroDelimiter::Brace,
 199                         tokens: TokenStream(`static FOO`),
 200                     },
 201                 },
 202                 Stmt::Macro {
 203                     mac: Macro {
 204                         path: Path {
 205                             segments: [
 206                                 PathSegment {
 207                                     ident: "println",
 208                                 },
 209                             ],
 210                         },
 211                         delimiter: MacroDelimiter::Paren,
 212                         tokens: TokenStream(`""`),
 213                     },
 214                     semi_token: Some,
 215                 },
 216                 Stmt::Expr(
 217                     Expr::Macro {
 218                         mac: Macro {
 219                             path: Path {
 220                                 segments: [
 221                                     PathSegment {
 222                                         ident: "vec",
 223                                     },
 224                                 ],
 225                             },
 226                             delimiter: MacroDelimiter::Bracket,
 227                             tokens: TokenStream(``),
 228                         },
 229                     },
 230                     None,
 231                 ),
 232             ],
 233         },
 234     })
 235     "###);
 236 }