feat: remove lazy_static in favor of LazyLock

This switches to the built-in `std::sync::LazyLock`

Author: nyurik

Cargo.lock

@@ -118,7 +118,6 @@ heck = "0.5.0"
 html-escape = "0.2.13"
 indexmap = "2.7.1"
 indoc = "2.0.5"
-lazy_static = "1.5.0"
 libloading = "0.8.6"
 log = { version = "0.4.25", features = ["std"] }
 memchr = "2.7.4"

Cargo.toml

@@ -43,7 +43,6 @@ heck.workspace = true
 html-escape.workspace = true
 indexmap.workspace = true
 indoc.workspace = true
-lazy_static.workspace = true
 log.workspace = true
 memchr.workspace = true
 rand.workspace = true

cli/Cargo.toml

@@ -3,68 +3,72 @@ use std::{
     env, fs,
     path::{Path, PathBuf},
     str,
+    sync::LazyLock,
     time::Instant,
 };
 
 use anyhow::Context;
-use lazy_static::lazy_static;
 use tree_sitter::{Language, Parser, Query};
 use tree_sitter_loader::{CompileConfig, Loader};
 
 include!("../src/tests/helpers/dirs.rs");
 
-lazy_static! {
-    static ref LANGUAGE_FILTER: Option<String> =
-        env::var("TREE_SITTER_BENCHMARK_LANGUAGE_FILTER").ok();
-    static ref EXAMPLE_FILTER: Option<String> =
-        env::var("TREE_SITTER_BENCHMARK_EXAMPLE_FILTER").ok();
-    static ref REPETITION_COUNT: usize = env::var("TREE_SITTER_BENCHMARK_REPETITION_COUNT")
+static LANGUAGE_FILTER: LazyLock<Option<String>> =
+    LazyLock::new(|| env::var("TREE_SITTER_BENCHMARK_LANGUAGE_FILTER").ok());
+static EXAMPLE_FILTER: LazyLock<Option<String>> =
+    LazyLock::new(|| env::var("TREE_SITTER_BENCHMARK_EXAMPLE_FILTER").ok());
+static REPETITION_COUNT: LazyLock<usize> = LazyLock::new(|| {
+    env::var("TREE_SITTER_BENCHMARK_REPETITION_COUNT")
         .map(|s| s.parse::<usize>().unwrap())
-        .unwrap_or(5);
-    static ref TEST_LOADER: Loader = Loader::with_parser_lib_path(SCRATCH_DIR.clone());
-    static ref EXAMPLE_AND_QUERY_PATHS_BY_LANGUAGE_DIR: BTreeMap<PathBuf, (Vec<PathBuf>, Vec<PathBuf>)> = {
-        fn process_dir(result: &mut BTreeMap<PathBuf, (Vec<PathBuf>, Vec<PathBuf>)>, dir: &Path) {
-            if dir.join("grammar.js").exists() {
-                let relative_path = dir.strip_prefix(GRAMMARS_DIR.as_path()).unwrap();
-                let (example_paths, query_paths) =
-                    result.entry(relative_path.to_owned()).or_default();
-
-                if let Ok(example_files) = fs::read_dir(dir.join("examples")) {
-                    example_paths.extend(example_files.filter_map(|p| {
-                        let p = p.unwrap().path();
-                        if p.is_file() {
-                            Some(p)
-                        } else {
-                            None
-                        }
-                    }));
-                }
+        .unwrap_or(5)
+});
+static TEST_LOADER: LazyLock<Loader> =
+    LazyLock::new(|| Loader::with_parser_lib_path(SCRATCH_DIR.clone()));
+
+#[allow(clippy::type_complexity)]
+static EXAMPLE_AND_QUERY_PATHS_BY_LANGUAGE_DIR: LazyLock<
+    BTreeMap<PathBuf, (Vec<PathBuf>, Vec<PathBuf>)>,
+> = LazyLock::new(|| {
+    fn process_dir(result: &mut BTreeMap<PathBuf, (Vec<PathBuf>, Vec<PathBuf>)>, dir: &Path) {
+        if dir.join("grammar.js").exists() {
+            let relative_path = dir.strip_prefix(GRAMMARS_DIR.as_path()).unwrap();
+            let (example_paths, query_paths) = result.entry(relative_path.to_owned()).or_default();
+
+            if let Ok(example_files) = fs::read_dir(dir.join("examples")) {
+                example_paths.extend(example_files.filter_map(|p| {
+                    let p = p.unwrap().path();
+                    if p.is_file() {
+                        Some(p)
+                    } else {
+                        None
+                    }
+                }));
+            }
 
-                if let Ok(query_files) = fs::read_dir(dir.join("queries")) {
-                    query_paths.extend(query_files.filter_map(|p| {
-                        let p = p.unwrap().path();
-                        if p.is_file() {
-                            Some(p)
-                        } else {
-                            None
-                        }
-                    }));
-                }
-            } else {
-                for entry in fs::read_dir(dir).unwrap() {
-                    let entry = entry.unwrap().path();
-                    if entry.is_dir() {
-                        process_dir(result, &entry);
+            if let Ok(query_files) = fs::read_dir(dir.join("queries")) {
+                query_paths.extend(query_files.filter_map(|p| {
+                    let p = p.unwrap().path();
+                    if p.is_file() {
+                        Some(p)
+                    } else {
+                        None
                     }
+                }));
+            }
+        } else {
+            for entry in fs::read_dir(dir).unwrap() {
+                let entry = entry.unwrap().path();
+                if entry.is_dir() {
+                    process_dir(result, &entry);
                 }
             }
         }
+    }
 
-        let mut result = BTreeMap::new();
-        process_dir(&mut result, &GRAMMARS_DIR);
-        result
-    };
-}
+    let mut result = BTreeMap::new();
+    process_dir(&mut result, &GRAMMARS_DIR);
+    result
+});
 
 fn main() {
     let max_path_length = EXAMPLE_AND_QUERY_PATHS_BY_LANGUAGE_DIR

cli/benches/benchmark.rs

@@ -20,7 +20,6 @@ anyhow.workspace = true
 heck.workspace = true
 indexmap.workspace = true
 indoc.workspace = true
-lazy_static.workspace = true
 log.workspace = true
 regex.workspace = true
 regex-syntax.workspace = true

cli/generate/Cargo.toml

@@ -2,10 +2,9 @@ use std::{
     cmp::Ordering,
     fmt,
     hash::{Hash, Hasher},
+    sync::LazyLock,
 };
 
-use lazy_static::lazy_static;
-
 use crate::{
     grammars::{
         LexicalGrammar, Production, ProductionStep, ReservedWordSetId, SyntaxGrammar,
@@ -14,22 +13,20 @@ use crate::{
     rules::{Associativity, Precedence, Symbol, SymbolType, TokenSet},
 };
 
-lazy_static! {
-    static ref START_PRODUCTION: Production = Production {
-        dynamic_precedence: 0,
-        steps: vec![ProductionStep {
-            symbol: Symbol {
-                index: 0,
-                kind: SymbolType::NonTerminal,
-            },
-            precedence: Precedence::None,
-            associativity: None,
-            alias: None,
-            field_name: None,
-            reserved_word_set_id: NO_RESERVED_WORDS,
-        }],
-    };
-}
+static START_PRODUCTION: LazyLock<Production> = LazyLock::new(|| Production {
+    dynamic_precedence: 0,
+    steps: vec![ProductionStep {
+        symbol: Symbol {
+            index: 0,
+            kind: SymbolType::NonTerminal,
+        },
+        precedence: Precedence::None,
+        associativity: None,
+        alias: None,
+        field_name: None,
+        reserved_word_set_id: NO_RESERVED_WORDS,
+    }],
+});
 
 /// A [`ParseItem`] represents an in-progress match of a single production in a grammar.
 #[derive(Clone, Copy, Debug)]

cli/generate/src/build_tables/item.rs

@@ -3,12 +3,12 @@ use std::{
     io::Write,
     path::{Path, PathBuf},
     process::{Command, Stdio},
+    sync::LazyLock,
 };
 
 use anyhow::Result;
 use build_tables::build_tables;
 use grammars::InputGrammar;
-use lazy_static::lazy_static;
 pub use node_types::VariableInfoError;
 use parse_grammar::parse_grammar;
 pub use parse_grammar::ParseGrammarError;
@@ -34,12 +34,12 @@ pub use build_tables::ParseTableBuilderError;
 use serde::Serialize;
 use thiserror::Error;
 
-lazy_static! {
-    static ref JSON_COMMENT_REGEX: Regex = RegexBuilder::new("^\\s*//.*")
+static JSON_COMMENT_REGEX: LazyLock<Regex> = LazyLock::new(|| {
+    RegexBuilder::new("^\\s*//.*")
         .multi_line(true)
         .build()
-        .unwrap();
-}
+        .unwrap()
+});
 
 struct GeneratedParser {
     c_code: String,

cli/generate/src/lib.rs

@@ -29,7 +29,6 @@ cc.workspace = true
 etcetera.workspace = true
 fs4.workspace = true
 indoc.workspace = true
-lazy_static.workspace = true
 libloading.workspace = true
 once_cell.workspace = true
 path-slash.workspace = true

cli/loader/Cargo.toml

@@ -14,6 +14,7 @@ use std::{
     mem,
     path::{Path, PathBuf},
     process::Command,
+    sync::LazyLock,
     time::SystemTime,
 };
 
@@ -23,7 +24,6 @@ use anyhow::{anyhow, Context, Result};
 use etcetera::BaseStrategy as _;
 use fs4::fs_std::FileExt;
 use indoc::indoc;
-use lazy_static::lazy_static;
 use libloading::{Library, Symbol};
 use once_cell::unsync::OnceCell;
 use path_slash::PathBufExt as _;
@@ -41,9 +41,8 @@ use tree_sitter_highlight::HighlightConfiguration;
 use tree_sitter_tags::{Error as TagsError, TagsConfiguration};
 use url::Url;
 
-lazy_static! {
-    static ref GRAMMAR_NAME_REGEX: Regex = Regex::new(r#""name":\s*"(.*?)""#).unwrap();
-}
+static GRAMMAR_NAME_REGEX: LazyLock<Regex> =
+    LazyLock::new(|| Regex::new(r#""name":\s*"(.*?)""#).unwrap());
 
 pub const EMSCRIPTEN_TAG: &str = concat!("docker.io/emscripten/emsdk:", env!("EMSCRIPTEN_VERSION"));
 

cli/loader/src/lib.rs

@@ -1,6 +1,5 @@
-use std::{collections::HashMap, env, fs, path::Path};
+use std::{collections::HashMap, env, fs, path::Path, sync::LazyLock};
 
-use lazy_static::lazy_static;
 use rand::Rng;
 use regex::Regex;
 use tree_sitter::{Language, Parser};
@@ -23,16 +22,27 @@ use crate::{
     test::{parse_tests, print_diff, print_diff_key, strip_sexp_fields, TestEntry},
 };
 
-lazy_static! {
-    pub static ref LOG_ENABLED: bool = env::var("TREE_SITTER_LOG").is_ok();
-    pub static ref LOG_GRAPH_ENABLED: bool = env::var("TREE_SITTER_LOG_GRAPHS").is_ok();
-    pub static ref LANGUAGE_FILTER: Option<String> = env::var("TREE_SITTER_LANGUAGE").ok();
-    pub static ref EXAMPLE_INCLUDE: Option<Regex> = regex_env_var("TREE_SITTER_EXAMPLE_INCLUDE");
-    pub static ref EXAMPLE_EXCLUDE: Option<Regex> = regex_env_var("TREE_SITTER_EXAMPLE_EXCLUDE");
-    pub static ref START_SEED: usize = new_seed();
-    pub static ref EDIT_COUNT: usize = int_env_var("TREE_SITTER_EDITS").unwrap_or(3);
-    pub static ref ITERATION_COUNT: usize = int_env_var("TREE_SITTER_ITERATIONS").unwrap_or(10);
-}
+pub static LOG_ENABLED: LazyLock<bool> = LazyLock::new(|| env::var("TREE_SITTER_LOG").is_ok());
+
+pub static LOG_GRAPH_ENABLED: LazyLock<bool> =
+    LazyLock::new(|| env::var("TREE_SITTER_LOG_GRAPHS").is_ok());
+
+pub static LANGUAGE_FILTER: LazyLock<Option<String>> =
+    LazyLock::new(|| env::var("TREE_SITTER_LANGUAGE").ok());
+
+pub static EXAMPLE_INCLUDE: LazyLock<Option<Regex>> =
+    LazyLock::new(|| regex_env_var("TREE_SITTER_EXAMPLE_INCLUDE"));
+
+pub static EXAMPLE_EXCLUDE: LazyLock<Option<Regex>> =
+    LazyLock::new(|| regex_env_var("TREE_SITTER_EXAMPLE_EXCLUDE"));
+
+pub static START_SEED: LazyLock<usize> = LazyLock::new(new_seed);
+
+pub static EDIT_COUNT: LazyLock<usize> =
+    LazyLock::new(|| int_env_var("TREE_SITTER_EDITS").unwrap_or(3));
+
+pub static ITERATION_COUNT: LazyLock<usize> =
+    LazyLock::new(|| int_env_var("TREE_SITTER_ITERATIONS").unwrap_or(10));
 
 fn int_env_var(name: &'static str) -> Option<usize> {
     env::var(name).ok().and_then(|e| e.parse().ok())