feat: create sym module for symbol interning

Author: BD103

bevy_lint/src/callback.rs

@@ -81,6 +81,15 @@ impl Callbacks for BevyLintCallback {
                 }
             }
         }));
+
+        // There shouldn't be any existing extra symbols, as we should be the only callback
+        // overriding them.
+        debug_assert!(config.extra_symbols.is_empty());
+
+        // Give the compiler a list of extra `Symbol`s to intern ahead of time. This helps us avoid
+        // calling `Symbol::intern()` while linting. See the `sym` module for a more detailed
+        // explanation.
+        config.extra_symbols = crate::sym::EXTRA_SYMBOLS.to_vec();
     }
 }
 

bevy_lint/src/lib.rs

@@ -16,6 +16,8 @@
 #![feature(rustc_private)]
 // Allows chaining `if let` multiple times using `&&`.
 #![feature(let_chains)]
+// Used to access the index of repeating macro input in `declare_bevy_symbols!`.
+#![feature(macro_metavar_expr)]
 // Warn on internal `rustc` lints that check for poor usage of internal compiler APIs. Note that
 // you also need to pass `-Z unstable-options` to `rustc` for this to be enabled:
 // `RUSTFLAGS="-Zunstable-options" cargo check`
@@ -46,6 +48,7 @@ mod config;
 mod lint;
 pub mod lints;
 mod paths;
+mod sym;
 mod utils;
 
 pub use self::callback::BevyLintCallback;

bevy_lint/src/sym.rs

@@ -0,0 +1,56 @@
+//! Pre-interned [`Symbol`]s available in `const` contexts.
+//!
+//! [`Symbol`]s are [interned strings](https://en.wikipedia.org/wiki/String_interning) that are
+//! cheap to store and compare. This module contains a list of pre-interned symbol constants that
+//! are used in the linter. The only exception to this is the [`EXTRA_SYMBOLS`] constant, which
+//! contains a complete ordered list of all symbols to be pre-interned.
+
+use rustc_span::{Symbol, symbol::PREDEFINED_SYMBOLS_COUNT};
+
+/// A helper used by [`declare_bevy_symbols!`] to extract its input.
+///
+/// ```
+/// assert_eq!(extract_value!(Name), "Name");
+/// assert_eq!(extract_value!(Name: "value"), "value");
+/// ```
+macro_rules! extract_value {
+    ($name:ident) => {
+        stringify!($name)
+    };
+    ($name:ident: $value:literal) => {
+        $value
+    };
+}
+
+/// Generates the [`Symbol`] constants and [`EXTRA_SYMBOLS`] from a list of name-value pairs.
+///
+/// # Example
+///
+/// ```
+/// declare_bevy_symbols! {
+///     // Interns the string "Hello, world" available as the constant named `Hello`.
+///     Hello: "Hello, world!",
+///     // Interns the string "bevy" available as the constant named `bevy`. This is the shorthand!
+///     bevy,
+/// }
+/// ```
+macro_rules! declare_bevy_symbols {
+    {
+        $($name:ident $(: $value:literal)?),* $(,)?
+    } => {
+        /// A list of strings that are pre-interned at the beginning of linting through
+        /// [`Config::extra_symbols`](rustc_interface::interface::Config::extra_symbols).
+        pub const EXTRA_SYMBOLS: &[&str] = &[
+            $(
+                extract_value!($name $(: $value)?)
+            ),*
+        ];
+
+        $(
+            #[doc = concat!("A pre-interned [`Symbol`] for the string \"", extract_value!($name $(: $value)?), "\".")]
+            pub const $name: Symbol = Symbol::new(PREDEFINED_SYMBOLS_COUNT + ${index()});
+        )*
+    };
+}
+
+declare_bevy_symbols! {}