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 from_str_stream = quote! {};
 101     let mut counter = 0u32;
 102     let mut keys = HashSet::<String>::new();
 103
 104     let mut check_dup = |str: &str| {
 105         if !keys.insert(str.to_string()) {
 106             panic!("Symbol `{}` is duplicated", str);
 107         }
 108     };
 109
 110     for keyword in &input.keywords.0 {
 111         let name = &keyword.name;
 112         let value = &keyword.value;
 113         check_dup(&value.value());
 114         prefill_stream.extend(quote! {
 115             #value,
 116         });
 117         keyword_stream.extend(quote! {
 118             pub const #name: Keyword = Keyword {
 119                 ident: Ident::with_empty_ctxt(super::Symbol::new(#counter))
 120             };
 121         });
 122         from_str_stream.extend(quote! {
 123             #value => Ok(#name),
 124         });
 125         counter += 1;
 126     }
 127
 128     for symbol in &input.symbols.0 {
 129         let name = &symbol.name;
 130         let value = match &symbol.value {
 131             Some(value) => value.value(),
 132             None => name.to_string(),
 133         };
 134         check_dup(&value);
 135         prefill_stream.extend(quote! {
 136             #value,
 137         });
 138         symbols_stream.extend(quote! {
 139             pub const #name: Symbol = Symbol::new(#counter);
 140         });
 141         counter += 1;
 142     }
 143
 144     let tt = TokenStream::from(quote! {
 145         macro_rules! keywords {
 146             () => {
 147                 #keyword_stream
 148
 149                 impl std::str::FromStr for Keyword {
 150                     type Err = ();
 151
 152                     fn from_str(s: &str) -> Result<Self, ()> {
 153                         match s {
 154                             #from_str_stream
 155                             _ => Err(()),
 156                         }
 157                     }
 158                 }
 159             }
 160         }
 161
 162         macro_rules! symbols {
 163             () => {
 164                 #symbols_stream
 165             }
 166         }
 167
 168         impl Interner {
 169             pub fn fresh() -> Self {
 170                 Interner::prefill(&[
 171                     #prefill_stream
 172                 ])
 173             }
 174         }
 175     });
 176
 177     // To see the generated code generated, uncomment this line, recompile, and
 178     // run the resulting output through `rustfmt`.
 179     //eprintln!("{}", tt);
 180
 181     tt
 182 }