Bump MSRV to Rust 1.80

Cargo.toml

@@ -4,7 +4,7 @@ resolver = "2"
 
 [workspace.package]
 edition = "2021"
-rust-version = "1.76"
+rust-version = "1.80"
 homepage = "https://docs.astral.sh/ruff"
 documentation = "https://docs.astral.sh/ruff"
 repository = "https://github.com/astral-sh/ruff"
@@ -101,7 +101,6 @@ memchr = { version = "2.7.1" }
 mimalloc = { version = "0.1.39" }
 natord = { version = "1.0.9" }
 notify = { version = "6.1.1" }
-once_cell = { version = "1.19.0" }
 ordermap = { version = "0.5.0" }
 path-absolutize = { version = "3.1.1" }
 path-slash = { version = "0.2.1" }

crates/red_knot_test/Cargo.toml

@@ -21,7 +21,6 @@ ruff_text_size = { workspace = true }
 
 anyhow = { workspace = true }
 colored = { workspace = true }
-once_cell = { workspace = true }
 regex = { workspace = true }
 rustc-hash = { workspace = true }
 salsa = { workspace = true }

crates/red_knot_test/src/assertion.rs

@@ -35,7 +35,6 @@
 //! ```
 
 use crate::db::Db;
-use once_cell::sync::Lazy;
 use regex::Regex;
 use ruff_db::files::File;
 use ruff_db::parsed::parsed_module;
@@ -45,6 +44,7 @@ use ruff_source_file::{LineIndex, Locator, OneIndexed};
 use ruff_text_size::{Ranged, TextRange};
 use smallvec::SmallVec;
 use std::ops::Deref;
+use std::sync::LazyLock;
 
 /// Diagnostic assertion comments in a single embedded file.
 #[derive(Debug)]
@@ -239,10 +239,10 @@ impl<'a> Deref for LineAssertions<'a> {
     }
 }
 
-static TYPE_RE: Lazy<Regex> =
-    Lazy::new(|| Regex::new(r"^#\s*revealed:\s*(?<ty_display>.+?)\s*$").unwrap());
+static TYPE_RE: LazyLock<Regex> =
+    LazyLock::new(|| Regex::new(r"^#\s*revealed:\s*(?<ty_display>.+?)\s*$").unwrap());
 
-static ERROR_RE: Lazy<Regex> = Lazy::new(|| {
+static ERROR_RE: LazyLock<Regex> = LazyLock::new(|| {
     Regex::new(
         r#"^#\s*error:(\s*(?<column>\d+))?(\s*\[(?<rule>.+?)\])?(\s*"(?<message>.+?)")?\s*$"#,
     )

crates/red_knot_test/src/parser.rs

@@ -1,7 +1,7 @@
-use once_cell::sync::Lazy;
 use regex::{Captures, Regex};
 use ruff_index::{newtype_index, IndexVec};
 use rustc_hash::{FxHashMap, FxHashSet};
+use std::sync::LazyLock;
 
 /// Parse the Markdown `source` as a test suite with given `title`.
 pub(crate) fn parse<'s>(title: &'s str, source: &'s str) -> anyhow::Result<MarkdownTestSuite<'s>> {
@@ -135,12 +135,12 @@ pub(crate) struct EmbeddedFile<'s> {
 
 /// Matches an arbitrary amount of whitespace (including newlines), followed by a sequence of `#`
 /// characters, followed by a title heading, followed by a newline.
-static HEADER_RE: Lazy<Regex> =
-    Lazy::new(|| Regex::new(r"^(\s*\n)*(?<level>#+)\s+(?<title>.+)\s*\n").unwrap());
+static HEADER_RE: LazyLock<Regex> =
+    LazyLock::new(|| Regex::new(r"^(\s*\n)*(?<level>#+)\s+(?<title>.+)\s*\n").unwrap());
 
 /// Matches a code block fenced by triple backticks, possibly with language and `key=val`
 /// configuration items following the opening backticks (in the "tag string" of the code block).
-static CODE_RE: Lazy<Regex> = Lazy::new(|| {
+static CODE_RE: LazyLock<Regex> = LazyLock::new(|| {
     Regex::new(r"^```(?<lang>\w+)(?<config>( +\S+)*)\s*\n(?<code>(.|\n)*?)\n?```\s*\n").unwrap()
 });
 

crates/red_knot_vendored/Cargo.toml

@@ -12,7 +12,6 @@ license = { workspace = true }
 
 [dependencies]
 ruff_db = { workspace = true }
-once_cell = { workspace = true }
 zip = { workspace = true }
 
 [build-dependencies]

crates/red_knot_vendored/src/lib.rs

@@ -1,14 +1,13 @@
-use once_cell::sync::Lazy;
-
 use ruff_db::vendored::VendoredFileSystem;
+use std::sync::LazyLock;
 
 // The file path here is hardcoded in this crate's `build.rs` script.
 // Luckily this crate will fail to build if this file isn't available at build time.
 static TYPESHED_ZIP_BYTES: &[u8] = include_bytes!(concat!(env!("OUT_DIR"), "/zipped_typeshed.zip"));
 
 pub fn file_system() -> &'static VendoredFileSystem {
-    static VENDORED_TYPESHED_STUBS: Lazy<VendoredFileSystem> =
-        Lazy::new(|| VendoredFileSystem::new_static(TYPESHED_ZIP_BYTES).unwrap());
+    static VENDORED_TYPESHED_STUBS: LazyLock<VendoredFileSystem> =
+        LazyLock::new(|| VendoredFileSystem::new_static(TYPESHED_ZIP_BYTES).unwrap());
     &VENDORED_TYPESHED_STUBS
 }
 

crates/ruff_benchmark/Cargo.toml

@@ -39,7 +39,6 @@ harness = false
 [dependencies]
 codspeed-criterion-compat = { workspace = true, default-features = false, optional = true }
 criterion = { workspace = true, default-features = false }
-once_cell = { workspace = true }
 rayon = { workspace = true }
 rustc-hash = { workspace = true }
 serde = { workspace = true }

crates/ruff_benchmark/src/lib.rs

@@ -82,7 +82,7 @@ impl TestFile {
     }
 }
 
-static TARGET_DIR: once_cell::sync::Lazy<PathBuf> = once_cell::sync::Lazy::new(|| {
+static TARGET_DIR: std::sync::LazyLock<PathBuf> = std::sync::LazyLock::new(|| {
     cargo_target_directory().unwrap_or_else(|| PathBuf::from("target"))
 });
 

crates/ruff_graph/Cargo.toml

@@ -20,7 +20,6 @@ ruff_python_parser = { workspace = true }
 
 anyhow = { workspace = true }
 clap = { workspace = true, optional = true }
-once_cell = { workspace = true }
 salsa = { workspace = true }
 schemars = { workspace = true, optional = true }
 serde = { workspace = true, optional = true }

crates/ruff_graph/src/db.rs

@@ -7,12 +7,11 @@ use ruff_db::system::{OsSystem, System, SystemPathBuf};
 use ruff_db::vendored::{VendoredFileSystem, VendoredFileSystemBuilder};
 use ruff_db::{Db as SourceDb, Upcast};
 
-static EMPTY_VENDORED: once_cell::sync::Lazy<VendoredFileSystem> =
-    once_cell::sync::Lazy::new(|| {
-        let mut builder = VendoredFileSystemBuilder::new(CompressionMethod::Stored);
-        builder.add_file("stdlib/VERSIONS", "\n").unwrap();
-        builder.finish().unwrap()
-    });
+static EMPTY_VENDORED: std::sync::LazyLock<VendoredFileSystem> = std::sync::LazyLock::new(|| {
+    let mut builder = VendoredFileSystemBuilder::new(CompressionMethod::Stored);
+    builder.add_file("stdlib/VERSIONS", "\n").unwrap();
+    builder.finish().unwrap()
+});
 
 #[salsa::db]
 #[derive(Default)]

crates/ruff_linter/Cargo.toml

@@ -46,10 +46,9 @@ libcst = { workspace = true }
 log = { workspace = true }
 memchr = { workspace = true }
 natord = { workspace = true }
-once_cell = { workspace = true }
 path-absolutize = { workspace = true, features = [
-  "once_cell_cache",
-  "use_unix_paths_on_wasm",
+    "once_cell_cache",
+    "use_unix_paths_on_wasm",
 ] }
 pathdiff = { workspace = true }
 pep440_rs = { workspace = true, features = ["serde"] }

crates/ruff_linter/src/linter.rs

@@ -1,4 +1,5 @@
 use std::borrow::Cow;
+use std::cell::LazyCell;
 use std::ops::Deref;
 use std::path::Path;
 
@@ -440,7 +441,7 @@ fn diagnostics_to_messages(
     locator: &Locator,
     directives: &Directives,
 ) -> Vec<Message> {
-    let file = once_cell::unsync::Lazy::new(|| {
+    let file = LazyCell::new(|| {
         let mut builder =
             SourceFileBuilder::new(path.to_string_lossy().as_ref(), locator.contents());
 

crates/ruff_linter/src/logging.rs

@@ -1,12 +1,11 @@
 use std::fmt::{Display, Formatter, Write};
 use std::path::{Path, PathBuf};
-use std::sync::Mutex;
+use std::sync::{LazyLock, Mutex};
 
 use anyhow::Result;
 use colored::Colorize;
 use fern;
 use log::Level;
-use once_cell::sync::Lazy;
 use ruff_python_parser::{ParseError, ParseErrorType};
 use rustc_hash::FxHashSet;
 
@@ -16,7 +15,7 @@ use crate::fs;
 use crate::source_kind::SourceKind;
 use ruff_notebook::Notebook;
 
-pub static IDENTIFIERS: Lazy<Mutex<Vec<&'static str>>> = Lazy::new(Mutex::default);
+pub static IDENTIFIERS: LazyLock<Mutex<Vec<&'static str>>> = LazyLock::new(Mutex::default);
 
 /// Warn a user once, with uniqueness determined by the given ID.
 #[macro_export]
@@ -35,7 +34,7 @@ macro_rules! warn_user_once_by_id {
     };
 }
 
-pub static MESSAGES: Lazy<Mutex<FxHashSet<String>>> = Lazy::new(Mutex::default);
+pub static MESSAGES: LazyLock<Mutex<FxHashSet<String>>> = LazyLock::new(Mutex::default);
 
 /// Warn a user once, if warnings are enabled, with uniqueness determined by the content of the
 /// message.

crates/ruff_linter/src/rule_redirects.rs

@@ -1,6 +1,5 @@
 use std::collections::HashMap;
-
-use once_cell::sync::Lazy;
+use std::sync::LazyLock;
 
 /// Returns the redirect target for the given code.
 pub(crate) fn get_redirect_target(code: &str) -> Option<&'static str> {
@@ -13,7 +12,7 @@ pub(crate) fn get_redirect(code: &str) -> Option<(&'static str, &'static str)> {
     REDIRECTS.get_key_value(code).map(|(k, v)| (*k, *v))
 }
 
-static REDIRECTS: Lazy<HashMap<&'static str, &'static str>> = Lazy::new(|| {
+static REDIRECTS: LazyLock<HashMap<&'static str, &'static str>> = LazyLock::new(|| {
     HashMap::from_iter([
         // The following are here because we don't yet have the many-to-one mapping enabled.
         ("SIM111", "SIM110"),

crates/ruff_linter/src/rules/eradicate/detection.rs

@@ -1,29 +1,28 @@
 /// See: [eradicate.py](https://github.com/myint/eradicate/blob/98f199940979c94447a461d50d27862b118b282d/eradicate.py)
 use aho_corasick::AhoCorasick;
 use itertools::Itertools;
-use once_cell::sync::Lazy;
 use regex::{Regex, RegexSet};
-
 use ruff_python_parser::parse_module;
 use ruff_python_trivia::{SimpleTokenKind, SimpleTokenizer};
 use ruff_text_size::TextSize;
+use std::sync::LazyLock;
 
-static CODE_INDICATORS: Lazy<AhoCorasick> = Lazy::new(|| {
+static CODE_INDICATORS: LazyLock<AhoCorasick> = LazyLock::new(|| {
     AhoCorasick::new([
         "(", ")", "[", "]", "{", "}", ":", "=", "%", "return", "break", "continue", "import",
     ])
     .unwrap()
 });
 
-static ALLOWLIST_REGEX: Lazy<Regex> = Lazy::new(|| {
+static ALLOWLIST_REGEX: LazyLock<Regex> = LazyLock::new(|| {
     Regex::new(
         r"^(?i)(?:pylint|pyright|noqa|nosec|region|endregion|type:\s*ignore|fmt:\s*(on|off)|isort:\s*(on|off|skip|skip_file|split|dont-add-imports(:\s*\[.*?])?)|mypy:|SPDX-License-Identifier:|(?:en)?coding[:=][ \t]*([-_.a-zA-Z0-9]+))",
     ).unwrap()
 });
 
-static HASH_NUMBER: Lazy<Regex> = Lazy::new(|| Regex::new(r"#\d").unwrap());
+static HASH_NUMBER: LazyLock<Regex> = LazyLock::new(|| Regex::new(r"#\d").unwrap());
 
-static POSITIVE_CASES: Lazy<RegexSet> = Lazy::new(|| {
+static POSITIVE_CASES: LazyLock<RegexSet> = LazyLock::new(|| {
     RegexSet::new([
         // Keywords
         r"^(?:elif\s+.*\s*:.*|else\s*:.*|try\s*:.*|finally\s*:.*|except.*:.*|case\s+.*\s*:.*)$",

crates/ruff_linter/src/rules/flake8_bandit/helpers.rs

@@ -1,10 +1,10 @@
-use once_cell::sync::Lazy;
 use regex::Regex;
 use ruff_python_ast::{self as ast, Expr};
+use std::sync::LazyLock;
 
 use ruff_python_semantic::SemanticModel;
 
-static PASSWORD_CANDIDATE_REGEX: Lazy<Regex> = Lazy::new(|| {
+static PASSWORD_CANDIDATE_REGEX: LazyLock<Regex> = LazyLock::new(|| {
     Regex::new(r"(^|_)(?i)(pas+wo?r?d|pass(phrase)?|pwd|token|secrete?)($|_)").unwrap()
 });
 

crates/ruff_linter/src/rules/flake8_bandit/rules/hardcoded_sql_expression.rs

@@ -1,5 +1,7 @@
-use once_cell::sync::Lazy;
+use std::sync::LazyLock;
+
 use regex::Regex;
+
 use ruff_diagnostics::{Diagnostic, Violation};
 use ruff_macros::{derive_message_formats, violation};
 use ruff_python_ast::str::raw_contents;
@@ -9,7 +11,7 @@ use ruff_text_size::Ranged;
 
 use crate::checkers::ast::Checker;
 
-static SQL_REGEX: Lazy<Regex> = Lazy::new(|| {
+static SQL_REGEX: LazyLock<Regex> = LazyLock::new(|| {
     Regex::new(r"(?i)\b(select\s+.*\s+from\s|delete\s+from\s|(insert|replace)\s+.*\s+values\s|update\s+.*\s+set\s)")
     .unwrap()
 });