Get rid of static predefined symbols

Make them all `const`.

Author: ChayimFriedman2

src/tools/rust-analyzer/crates/hir-def/src/attr.rs

@@ -117,17 +117,20 @@ impl Attrs {
 }
 
 impl Attrs {
-    pub fn by_key<'attrs>(&'attrs self, key: &'attrs Symbol) -> AttrQuery<'attrs> {
+    #[inline]
+    pub fn by_key(&self, key: Symbol) -> AttrQuery<'_> {
         AttrQuery { attrs: self, key }
     }
 
+    #[inline]
     pub fn rust_analyzer_tool(&self) -> impl Iterator<Item = &Attr> {
         self.iter()
             .filter(|&attr| attr.path.segments().first().is_some_and(|s| *s == sym::rust_analyzer))
     }
 
+    #[inline]
     pub fn cfg(&self) -> Option<CfgExpr> {
-        let mut cfgs = self.by_key(&sym::cfg).tt_values().map(CfgExpr::parse);
+        let mut cfgs = self.by_key(sym::cfg).tt_values().map(CfgExpr::parse);
         let first = cfgs.next()?;
         match cfgs.next() {
             Some(second) => {
@@ -138,63 +141,76 @@ impl Attrs {
         }
     }
 
+    #[inline]
     pub fn cfgs(&self) -> impl Iterator<Item = CfgExpr> + '_ {
-        self.by_key(&sym::cfg).tt_values().map(CfgExpr::parse)
+        self.by_key(sym::cfg).tt_values().map(CfgExpr::parse)
     }
 
+    #[inline]
     pub(crate) fn is_cfg_enabled(&self, cfg_options: &CfgOptions) -> bool {
         match self.cfg() {
             None => true,
             Some(cfg) => cfg_options.check(&cfg) != Some(false),
         }
     }
 
+    #[inline]
     pub fn lang(&self) -> Option<&Symbol> {
-        self.by_key(&sym::lang).string_value()
+        self.by_key(sym::lang).string_value()
     }
 
+    #[inline]
     pub fn lang_item(&self) -> Option<LangItem> {
-        self.by_key(&sym::lang).string_value().and_then(LangItem::from_symbol)
+        self.by_key(sym::lang).string_value().and_then(LangItem::from_symbol)
     }
 
+    #[inline]
     pub fn has_doc_hidden(&self) -> bool {
-        self.by_key(&sym::doc).tt_values().any(|tt| {
+        self.by_key(sym::doc).tt_values().any(|tt| {
             tt.top_subtree().delimiter.kind == DelimiterKind::Parenthesis &&
                 matches!(tt.token_trees().flat_tokens(), [tt::TokenTree::Leaf(tt::Leaf::Ident(ident))] if ident.sym == sym::hidden)
         })
     }
 
+    #[inline]
     pub fn has_doc_notable_trait(&self) -> bool {
-        self.by_key(&sym::doc).tt_values().any(|tt| {
+        self.by_key(sym::doc).tt_values().any(|tt| {
             tt.top_subtree().delimiter.kind == DelimiterKind::Parenthesis &&
                 matches!(tt.token_trees().flat_tokens(), [tt::TokenTree::Leaf(tt::Leaf::Ident(ident))] if ident.sym == sym::notable_trait)
         })
     }
 
+    #[inline]
     pub fn doc_exprs(&self) -> impl Iterator<Item = DocExpr> + '_ {
-        self.by_key(&sym::doc).tt_values().map(DocExpr::parse)
+        self.by_key(sym::doc).tt_values().map(DocExpr::parse)
     }
 
+    #[inline]
     pub fn doc_aliases(&self) -> impl Iterator<Item = Symbol> + '_ {
         self.doc_exprs().flat_map(|doc_expr| doc_expr.aliases().to_vec())
     }
 
+    #[inline]
     pub fn export_name(&self) -> Option<&Symbol> {
-        self.by_key(&sym::export_name).string_value()
+        self.by_key(sym::export_name).string_value()
     }
 
+    #[inline]
     pub fn is_proc_macro(&self) -> bool {
-        self.by_key(&sym::proc_macro).exists()
+        self.by_key(sym::proc_macro).exists()
     }
 
+    #[inline]
     pub fn is_proc_macro_attribute(&self) -> bool {
-        self.by_key(&sym::proc_macro_attribute).exists()
+        self.by_key(sym::proc_macro_attribute).exists()
     }
 
+    #[inline]
     pub fn is_proc_macro_derive(&self) -> bool {
-        self.by_key(&sym::proc_macro_derive).exists()
+        self.by_key(sym::proc_macro_derive).exists()
     }
 
+    #[inline]
     pub fn is_test(&self) -> bool {
         self.iter().any(|it| {
             it.path()
@@ -210,29 +226,34 @@ impl Attrs {
         })
     }
 
+    #[inline]
     pub fn is_ignore(&self) -> bool {
-        self.by_key(&sym::ignore).exists()
+        self.by_key(sym::ignore).exists()
     }
 
+    #[inline]
     pub fn is_bench(&self) -> bool {
-        self.by_key(&sym::bench).exists()
+        self.by_key(sym::bench).exists()
     }
 
+    #[inline]
     pub fn is_unstable(&self) -> bool {
-        self.by_key(&sym::unstable).exists()
+        self.by_key(sym::unstable).exists()
     }
 
+    #[inline]
     pub fn rustc_legacy_const_generics(&self) -> Option<Box<Box<[u32]>>> {
-        self.by_key(&sym::rustc_legacy_const_generics)
+        self.by_key(sym::rustc_legacy_const_generics)
             .tt_values()
             .next()
             .map(parse_rustc_legacy_const_generics)
             .filter(|it| !it.is_empty())
             .map(Box::new)
     }
 
+    #[inline]
     pub fn repr(&self) -> Option<ReprOptions> {
-        self.by_key(&sym::repr).tt_values().filter_map(parse_repr_tt).fold(None, |acc, repr| {
+        self.by_key(sym::repr).tt_values().filter_map(parse_repr_tt).fold(None, |acc, repr| {
             acc.map_or(Some(repr), |mut acc| {
                 merge_repr(&mut acc, repr);
                 Some(acc)
@@ -681,36 +702,42 @@ impl AttrSourceMap {
     }
 }
 
-#[derive(Debug, Clone, Copy)]
+#[derive(Debug, Clone)]
 pub struct AttrQuery<'attr> {
     attrs: &'attr Attrs,
-    key: &'attr Symbol,
+    key: Symbol,
 }
 
 impl<'attr> AttrQuery<'attr> {
+    #[inline]
     pub fn tt_values(self) -> impl Iterator<Item = &'attr crate::tt::TopSubtree> {
         self.attrs().filter_map(|attr| attr.token_tree_value())
     }
 
+    #[inline]
     pub fn string_value(self) -> Option<&'attr Symbol> {
         self.attrs().find_map(|attr| attr.string_value())
     }
 
+    #[inline]
     pub fn string_value_with_span(self) -> Option<(&'attr Symbol, span::Span)> {
         self.attrs().find_map(|attr| attr.string_value_with_span())
     }
 
+    #[inline]
     pub fn string_value_unescape(self) -> Option<Cow<'attr, str>> {
         self.attrs().find_map(|attr| attr.string_value_unescape())
     }
 
+    #[inline]
     pub fn exists(self) -> bool {
         self.attrs().next().is_some()
     }
 
+    #[inline]
     pub fn attrs(self) -> impl Iterator<Item = &'attr Attr> + Clone {
         let key = self.key;
-        self.attrs.iter().filter(move |attr| attr.path.as_ident().is_some_and(|s| *s == *key))
+        self.attrs.iter().filter(move |attr| attr.path.as_ident().is_some_and(|s| *s == key))
     }
 
     /// Find string value for a specific key inside token tree
@@ -719,10 +746,11 @@ impl<'attr> AttrQuery<'attr> {
     /// #[doc(html_root_url = "url")]
     ///       ^^^^^^^^^^^^^ key
     /// ```
-    pub fn find_string_value_in_tt(self, key: &'attr Symbol) -> Option<&'attr str> {
+    #[inline]
+    pub fn find_string_value_in_tt(self, key: Symbol) -> Option<&'attr str> {
         self.tt_values().find_map(|tt| {
             let name = tt.iter()
-                .skip_while(|tt| !matches!(tt, TtElement::Leaf(tt::Leaf::Ident(tt::Ident { sym, ..} )) if *sym == *key))
+                .skip_while(|tt| !matches!(tt, TtElement::Leaf(tt::Leaf::Ident(tt::Ident { sym, ..} )) if *sym == key))
                 .nth(2);
 
             match name {

src/tools/rust-analyzer/crates/hir-def/src/nameres/collector.rs

@@ -1712,7 +1712,7 @@ impl ModCollector<'_, '_> {
                         id: ItemTreeId::new(self.tree_id, item_tree_id),
                     }
                     .intern(db);
-                    let is_prelude = attrs.by_key(&sym::prelude_import).exists();
+                    let is_prelude = attrs.by_key(sym::prelude_import).exists();
                     Import::from_use(
                         self.item_tree,
                         ItemTreeId::new(self.tree_id, item_tree_id),
@@ -1770,7 +1770,7 @@ impl ModCollector<'_, '_> {
                             if !is_self {
                                 self.process_macro_use_extern_crate(
                                     id,
-                                    attrs.by_key(&sym::macro_use).attrs(),
+                                    attrs.by_key(sym::macro_use).attrs(),
                                     resolved.krate,
                                 );
                             }
@@ -2015,8 +2015,8 @@ impl ModCollector<'_, '_> {
     }
 
     fn collect_module(&mut self, module_id: FileItemTreeId<Mod>, attrs: &Attrs) {
-        let path_attr = attrs.by_key(&sym::path).string_value_unescape();
-        let is_macro_use = attrs.by_key(&sym::macro_use).exists();
+        let path_attr = attrs.by_key(sym::path).string_value_unescape();
+        let is_macro_use = attrs.by_key(sym::macro_use).exists();
         let module = &self.item_tree[module_id];
         match &module.kind {
             // inline module, just recurse
@@ -2093,7 +2093,7 @@ impl ModCollector<'_, '_> {
                                 let is_macro_use = is_macro_use
                                     || item_tree
                                         .top_level_attrs(db, krate)
-                                        .by_key(&sym::macro_use)
+                                        .by_key(sym::macro_use)
                                         .exists();
                                 if is_macro_use {
                                     self.import_all_legacy_macros(module_id);
@@ -2252,11 +2252,11 @@ impl ModCollector<'_, '_> {
         let attrs = self.item_tree.attrs(self.def_collector.db, krate, ModItem::from(id).into());
         let ast_id = InFile::new(self.file_id(), mac.ast_id.upcast());
 
-        let export_attr = attrs.by_key(&sym::macro_export);
+        let export_attr = || attrs.by_key(sym::macro_export);
 
-        let is_export = export_attr.exists();
+        let is_export = export_attr().exists();
         let local_inner = if is_export {
-            export_attr.tt_values().flat_map(|it| it.iter()).any(|it| match it {
+            export_attr().tt_values().flat_map(|it| it.iter()).any(|it| match it {
                 tt::TtElement::Leaf(tt::Leaf::Ident(ident)) => ident.sym == sym::local_inner_macros,
                 _ => false,
             })
@@ -2265,17 +2265,17 @@ impl ModCollector<'_, '_> {
         };
 
         // Case 1: builtin macros
-        let expander = if attrs.by_key(&sym::rustc_builtin_macro).exists() {
+        let expander = if attrs.by_key(sym::rustc_builtin_macro).exists() {
             // `#[rustc_builtin_macro = "builtin_name"]` overrides the `macro_rules!` name.
             let name;
-            let name = match attrs.by_key(&sym::rustc_builtin_macro).string_value_with_span() {
+            let name = match attrs.by_key(sym::rustc_builtin_macro).string_value_with_span() {
                 Some((it, span)) => {
                     name = Name::new_symbol(it.clone(), span.ctx);
                     &name
                 }
                 None => {
                     let explicit_name =
-                        attrs.by_key(&sym::rustc_builtin_macro).tt_values().next().and_then(|tt| {
+                        attrs.by_key(sym::rustc_builtin_macro).tt_values().next().and_then(|tt| {
                             match tt.token_trees().flat_tokens().first() {
                                 Some(tt::TokenTree::Leaf(tt::Leaf::Ident(name))) => Some(name),
                                 _ => None,
@@ -2305,7 +2305,7 @@ impl ModCollector<'_, '_> {
             // Case 2: normal `macro_rules!` macro
             MacroExpander::Declarative
         };
-        let allow_internal_unsafe = attrs.by_key(&sym::allow_internal_unsafe).exists();
+        let allow_internal_unsafe = attrs.by_key(sym::allow_internal_unsafe).exists();
 
         let mut flags = MacroRulesLocFlags::empty();
         flags.set(MacroRulesLocFlags::LOCAL_INNER, local_inner);
@@ -2339,14 +2339,14 @@ impl ModCollector<'_, '_> {
         // Case 1: builtin macros
         let mut helpers_opt = None;
         let attrs = self.item_tree.attrs(self.def_collector.db, krate, ModItem::from(id).into());
-        let expander = if attrs.by_key(&sym::rustc_builtin_macro).exists() {
+        let expander = if attrs.by_key(sym::rustc_builtin_macro).exists() {
             if let Some(expander) = find_builtin_macro(&mac.name) {
                 match expander {
                     Either::Left(it) => MacroExpander::BuiltIn(it),
                     Either::Right(it) => MacroExpander::BuiltInEager(it),
                 }
             } else if let Some(expander) = find_builtin_derive(&mac.name) {
-                if let Some(attr) = attrs.by_key(&sym::rustc_builtin_macro).tt_values().next() {
+                if let Some(attr) = attrs.by_key(sym::rustc_builtin_macro).tt_values().next() {
                     // NOTE: The item *may* have both `#[rustc_builtin_macro]` and `#[proc_macro_derive]`,
                     // in which case rustc ignores the helper attributes from the latter, but it
                     // "doesn't make sense in practice" (see rust-lang/rust#87027).
@@ -2377,7 +2377,7 @@ impl ModCollector<'_, '_> {
             // Case 2: normal `macro`
             MacroExpander::Declarative
         };
-        let allow_internal_unsafe = attrs.by_key(&sym::allow_internal_unsafe).exists();
+        let allow_internal_unsafe = attrs.by_key(sym::allow_internal_unsafe).exists();
 
         let macro_id = Macro2Loc {
             container: module,

src/tools/rust-analyzer/crates/hir-def/src/nameres/proc_macro.rs

@@ -35,7 +35,7 @@ impl Attrs {
             Some(ProcMacroDef { name: func_name.clone(), kind: ProcMacroKind::Bang })
         } else if self.is_proc_macro_attribute() {
             Some(ProcMacroDef { name: func_name.clone(), kind: ProcMacroKind::Attr })
-        } else if self.by_key(&sym::proc_macro_derive).exists() {
+        } else if self.by_key(sym::proc_macro_derive).exists() {
             let derive = self.parse_proc_macro_derive();
             Some(match derive {
                 Some((name, helpers)) => {
@@ -52,12 +52,12 @@ impl Attrs {
     }
 
     pub fn parse_proc_macro_derive(&self) -> Option<(Name, Box<[Name]>)> {
-        let derive = self.by_key(&sym::proc_macro_derive).tt_values().next()?;
+        let derive = self.by_key(sym::proc_macro_derive).tt_values().next()?;
         parse_macro_name_and_helper_attrs(derive)
     }
 
     pub fn parse_rustc_builtin_macro(&self) -> Option<(Name, Box<[Name]>)> {
-        let derive = self.by_key(&sym::rustc_builtin_macro).tt_values().next()?;
+        let derive = self.by_key(sym::rustc_builtin_macro).tt_values().next()?;
         parse_macro_name_and_helper_attrs(derive)
     }
 }