bjoernager/rust
bjoernager/rust
1
Fork 0
Code Issues Pull requests Activity

Stop using intermediate macros in definition of symbols

Browse source 
Currently, the rustc_macros::symbols macro generates two
`macro_rules!` macros as its output. These two macros are
used in rustc_span/src/symbol.rs.

This means that each Symbol that we define is represented
in the AST of rustc_symbols twice: once in the definition
of the `define_symbols!` macro (similarly for the
`keywords! macro), and once in the rustc_span::symbols
definition.

That would be OK if there were only a handful of symbols,
but currently we define over 1100 symbols. The definition
of the `define_symbols!` macro contains the expanded definition
of each symbol, so that's a lot of AST storage wasted on a
macro that is used exactly once.

This commit removes the `define_symbols` macro, and simply
allows the proc macro to directly generate the
`rustc_symbols::symbol::sym` module.

The benefit is mainly in reducing memory wasted during
compilation of rustc itself. It should also reduce memory used
by Rust Analyzer.

This commit also reduces the size of the AST for symbol
definitions, by moving two `#[allow(...)]` attributes from
the symbol constants to the `sym` module. This eliminates 2200+
attribute nodes.

This commit also eliminates the need for the `digits_array`
constant. There's no need to store an array of Symbol values
for digits. We can simply define a constant of the base value,
and add to that base value.
This commit is contained in:
Arlie Davis 2020-12-14 11:34:55 -08:00
parent eb4fc71dc9
commit 2b2462e8b0
2 changed files with 24 additions and 29 deletions
Download patch file Download diff file Expand all files Collapse all files

37
compiler/rustc_macros/src/symbols.rs
View file

@ -126,7 +126,6 @@ fn symbols_with_errors(input: TokenStream) -> (TokenStream, Vec<syn::Error>) {
let mut keyword_stream = quote! {};
let mut symbols_stream = quote! {};
let mut digits_stream = quote! {};
let mut prefill_stream = quote! {};
let mut counter = 0u32;
let mut keys =
@ -162,7 +161,6 @@ fn symbols_with_errors(input: TokenStream) -> (TokenStream, Vec<syn::Error>) {
#value,
});
keyword_stream.extend(quote! {
#[allow(non_upper_case_globals)]
pub const #name: Symbol = Symbol::new(#counter);
});
counter += 1;
@ -182,42 +180,39 @@ fn symbols_with_errors(input: TokenStream) -> (TokenStream, Vec<syn::Error>) {
#value,
});
symbols_stream.extend(quote! {
#[allow(rustc::default_hash_types)]
#[allow(non_upper_case_globals)]
pub const #name: Symbol = Symbol::new(#counter);
});
counter += 1;
}
// Generate symbols for the strings "0", "1", ..., "9".
let digits_base = counter;
counter += 10;
for n in 0..10 {
let n = n.to_string();
check_dup(Span::call_site(), &n, &mut errors);
prefill_stream.extend(quote! {
#n,
});
digits_stream.extend(quote! {
Symbol::new(#counter),
});
counter += 1;
}
let _ = counter; // for future use
let output = quote! {
macro_rules! keywords {
() => {
#keyword_stream
}
const SYMBOL_DIGITS_BASE: u32 = #digits_base;
#[doc(hidden)]
#[allow(non_upper_case_globals)]
mod kw_generated {
use super::Symbol;
#keyword_stream
}
macro_rules! define_symbols {
() => {
#symbols_stream
#[allow(non_upper_case_globals)]
pub const digits_array: &[Symbol; 10] = &[
#digits_stream
];
}
#[allow(rustc::default_hash_types)]
#[allow(non_upper_case_globals)]
#[doc(hidden)]
pub mod sym_generated {
use super::Symbol;
#symbols_stream
}
impl Interner {