src/librustc_macros/src/symbols.rs

   1 use proc_macro::TokenStream;
   2 use syn::{
   3     Token, Ident, LitStr,
   4     braced, parse_macro_input,
   5 };
   6 use syn::parse::{Result, Parse, ParseStream};
   7 use syn;
   8 use std::collections::HashSet;
   9 use quote::quote;
  10
  11 #[allow(non_camel_case_types)]
  12 mod kw {
  13     syn::custom_keyword!(Keywords);
  14     syn::custom_keyword!(Symbols);
  15 }
  16
  17 struct Keyword {
  18     name: Ident,
  19     value: LitStr,
  20 }
  21
  22 impl Parse for Keyword {
  23     fn parse(input: ParseStream<'_>) -> Result<Self> {
  24         let name = input.parse()?;
  25         input.parse::<Token![:]>()?;
  26         let value = input.parse()?;
  27         input.parse::<Token![,]>()?;
  28
  29         Ok(Keyword {
  30             name,
  31             value,
  32         })
  33     }
  34 }
  35
  36 struct Symbol {
  37     name: Ident,
  38     value: Option<LitStr>,
  39 }
  40
  41 impl Parse for Symbol {
  42     fn parse(input: ParseStream<'_>) -> Result<Self> {
  43         let name = input.parse()?;
  44         let value = match input.parse::<Token![:]>() {
  45             Ok(_) => Some(input.parse()?),
  46             Err(_) => None,
  47         };
  48         input.parse::<Token![,]>()?;
  49
  50         Ok(Symbol {
  51             name,
  52             value,
  53         })
  54     }
  55 }
  56
  57 /// A type used to greedily parse another type until the input is empty.
  58 struct List<T>(Vec<T>);
  59
  60 impl<T: Parse> Parse for List<T> {
  61     fn parse(input: ParseStream<'_>) -> Result<Self> {
  62         let mut list = Vec::new();
  63         while !input.is_empty() {
  64             list.push(input.parse()?);
  65         }
  66         Ok(List(list))
  67     }
  68 }
  69
  70 struct Input {
  71     keywords: List<Keyword>,
  72     symbols: List<Symbol>,
  73 }
  74
  75 impl Parse for Input {
  76     fn parse(input: ParseStream<'_>) -> Result<Self> {
  77         input.parse::<kw::Keywords>()?;
  78         let content;
  79         braced!(content in input);
  80         let keywords = content.parse()?;
  81
  82         input.parse::<kw::Symbols>()?;
  83         let content;
  84         braced!(content in input);
  85         let symbols = content.parse()?;
  86
  87         Ok(Input {
  88             keywords,
  89             symbols,
  90         })
  91     }
  92 }
  93
  94 pub fn symbols(input: TokenStream) -> TokenStream {
  95     let input = parse_macro_input!(input as Input);
  96
  97     let mut keyword_stream = quote! {};
  98     let mut symbols_stream = quote! {};
  99     let mut prefill_stream = quote! {};
 100     let mut counter = 0u32;
 101     let mut keys = HashSet::<String>::new();
 102
 103     let mut check_dup = |str: &str| {
 104         if !keys.insert(str.to_string()) {
 105             panic!("Symbol `{}` is duplicated", str);
 106         }
 107     };
 108
 109     for keyword in &input.keywords.0 {
 110         let name = &keyword.name;
 111         let value = &keyword.value;
 112         check_dup(&value.value());
 113         prefill_stream.extend(quote! {
 114             #value,
 115         });
 116         keyword_stream.extend(quote! {
 117             pub const #name: Symbol = Symbol::new(#counter);
 118         });
 119         counter += 1;
 120     }
 121
 122     for symbol in &input.symbols.0 {
 123         let name = &symbol.name;
 124         let value = match &symbol.value {
 125             Some(value) => value.value(),
 126             None => name.to_string(),
 127         };
 128         check_dup(&value);
 129         prefill_stream.extend(quote! {
 130             #value,
 131         });
 132         symbols_stream.extend(quote! {
 133             pub const #name: Symbol = Symbol::new(#counter);
 134         });
 135         counter += 1;
 136     }
 137
 138     let tt = TokenStream::from(quote! {
 139         macro_rules! keywords {
 140             () => {
 141                 #keyword_stream
 142             }
 143         }
 144
 145         macro_rules! symbols {
 146             () => {
 147                 #symbols_stream
 148             }
 149         }
 150
 151         impl Interner {
 152             pub fn fresh() -> Self {
 153                 Interner::prefill(&[
 154                     #prefill_stream
 155                 ])
 156             }
 157         }
 158     });
 159
 160     // To see the generated code generated, uncomment this line, recompile, and
 161     // run the resulting output through `rustfmt`.
 162     //eprintln!("{}", tt);
 163
 164     tt
 165 }