src/test/ui/proc-macro/auxiliary/test-macros.rs

   1 // force-host
   2 // no-prefer-dynamic
   3
   4 // Proc macros commonly used by tests.
   5 // `panic`/`print` -> `panic_bang`/`print_bang` to avoid conflicts with standard macros.
   6
   7 #![crate_type = "proc-macro"]
   8
   9 extern crate proc_macro;
  10 use proc_macro::TokenStream;
  11
  12 // Macro that return empty token stream.
  13
  14 #[proc_macro]
  15 pub fn empty(_: TokenStream) -> TokenStream {
  16     TokenStream::new()
  17 }
  18
  19 #[proc_macro_attribute]
  20 pub fn empty_attr(_: TokenStream, _: TokenStream) -> TokenStream {
  21     TokenStream::new()
  22 }
  23
  24 #[proc_macro_derive(Empty, attributes(empty_helper))]
  25 pub fn empty_derive(_: TokenStream) -> TokenStream {
  26     TokenStream::new()
  27 }
  28
  29 // Macro that panics.
  30
  31 #[proc_macro]
  32 pub fn panic_bang(_: TokenStream) -> TokenStream {
  33     panic!("panic-bang");
  34 }
  35
  36 #[proc_macro_attribute]
  37 pub fn panic_attr(_: TokenStream, _: TokenStream) -> TokenStream {
  38     panic!("panic-attr");
  39 }
  40
  41 #[proc_macro_derive(Panic, attributes(panic_helper))]
  42 pub fn panic_derive(_: TokenStream) -> TokenStream {
  43     panic!("panic-derive");
  44 }
  45
  46 // Macros that return the input stream.
  47
  48 #[proc_macro]
  49 pub fn identity(input: TokenStream) -> TokenStream {
  50     input
  51 }
  52
  53 #[proc_macro_attribute]
  54 pub fn identity_attr(_: TokenStream, input: TokenStream) -> TokenStream {
  55     input
  56 }
  57
  58 #[proc_macro_derive(Identity, attributes(identity_helper))]
  59 pub fn identity_derive(input: TokenStream) -> TokenStream {
  60     input
  61 }
  62
  63 // Macros that iterate and re-collect the input stream.
  64
  65 #[proc_macro]
  66 pub fn recollect(input: TokenStream) -> TokenStream {
  67     input.into_iter().collect()
  68 }
  69
  70 #[proc_macro_attribute]
  71 pub fn recollect_attr(_: TokenStream, input: TokenStream) -> TokenStream {
  72     input.into_iter().collect()
  73 }
  74
  75 #[proc_macro_derive(Recollect, attributes(recollect_helper))]
  76 pub fn recollect_derive(input: TokenStream) -> TokenStream {
  77     input.into_iter().collect()
  78 }
  79
  80 // Macros that print their input in the original and re-collected forms (if they differ).
  81
  82 fn print_helper(input: TokenStream, kind: &str) -> TokenStream {
  83     let input_display = format!("{}", input);
  84     let input_debug = format!("{:#?}", input);
  85     let recollected = input.into_iter().collect();
  86     let recollected_display = format!("{}", recollected);
  87     let recollected_debug = format!("{:#?}", recollected);
  88     println!("PRINT-{} INPUT (DISPLAY): {}", kind, input_display);
  89     if recollected_display != input_display {
  90         println!("PRINT-{} RE-COLLECTED (DISPLAY): {}", kind, recollected_display);
  91     }
  92     println!("PRINT-{} INPUT (DEBUG): {}", kind, input_debug);
  93     if recollected_debug != input_debug {
  94         println!("PRINT-{} RE-COLLECTED (DEBUG): {}", kind, recollected_debug);
  95     }
  96     recollected
  97 }
  98
  99 #[proc_macro]
 100 pub fn print_bang(input: TokenStream) -> TokenStream {
 101     print_helper(input, "BANG")
 102 }
 103
 104 #[proc_macro]
 105 pub fn print_bang_consume(input: TokenStream) -> TokenStream {
 106     print_helper(input, "BANG");
 107     TokenStream::new()
 108 }
 109
 110 #[proc_macro_attribute]
 111 pub fn print_attr(_: TokenStream, input: TokenStream) -> TokenStream {
 112     print_helper(input, "ATTR")
 113 }
 114
 115 #[proc_macro_derive(Print, attributes(print_helper))]
 116 pub fn print_derive(input: TokenStream) -> TokenStream {
 117     print_helper(input, "DERIVE");
 118     TokenStream::new()
 119 }