Inline NodeKey construction and avoid AnyNodeRef

CHANGELOG.md

@@ -1,39 +1,5 @@
 # Changelog
 
-## 0.6.2
-
-### Preview features
-
-- \[`flake8-simplify`\] Extend `open-file-with-context-handler` to work with other standard-library IO modules (`SIM115`) ([#12959](https://github.com/astral-sh/ruff/pull/12959))
-- \[`ruff`\] Avoid `unused-async` for functions with FastAPI route decorator (`RUF029`) ([#12938](https://github.com/astral-sh/ruff/pull/12938))
-- \[`ruff`\] Ignore `fstring-missing-syntax` (`RUF027`) for `fastAPI` paths ([#12939](https://github.com/astral-sh/ruff/pull/12939))
-- \[`ruff`\] Implement check for Decimal called with a float literal (RUF032) ([#12909](https://github.com/astral-sh/ruff/pull/12909))
-
-### Rule changes
-
-- \[`flake8-bugbear`\] Update diagnostic message when expression is at the end of function (`B015`) ([#12944](https://github.com/astral-sh/ruff/pull/12944))
-- \[`flake8-pyi`\] Skip type annotations in `string-or-bytes-too-long` (`PYI053`) ([#13002](https://github.com/astral-sh/ruff/pull/13002))
-- \[`flake8-type-checking`\] Always recognise relative imports as first-party ([#12994](https://github.com/astral-sh/ruff/pull/12994))
-- \[`flake8-unused-arguments`\] Ignore unused arguments on stub functions (`ARG001`) ([#12966](https://github.com/astral-sh/ruff/pull/12966))
-- \[`pylint`\] Ignore augmented assignment for `self-cls-assignment` (`PLW0642`) ([#12957](https://github.com/astral-sh/ruff/pull/12957))
-
-### Server
-
-- Show full context in error log messages ([#13029](https://github.com/astral-sh/ruff/pull/13029))
-
-### Bug fixes
-
-- \[`pep8-naming`\] Don't flag `from` imports following conventional import names (`N817`) ([#12946](https://github.com/astral-sh/ruff/pull/12946))
-- \[`pylint`\] - Allow `__new__` methods to have `cls` as their first argument even if decorated with `@staticmethod` for `bad-staticmethod-argument` (`PLW0211`) ([#12958](https://github.com/astral-sh/ruff/pull/12958))
-
-### Documentation
-
-- Add `hyperfine` installation instructions; update `hyperfine` code samples ([#13034](https://github.com/astral-sh/ruff/pull/13034))
-- Expand note to use Ruff with other language server in Kate ([#12806](https://github.com/astral-sh/ruff/pull/12806))
-- Update example for `PT001` as per the new default behavior ([#13019](https://github.com/astral-sh/ruff/pull/13019))
-- \[`perflint`\] Improve docs for `try-except-in-loop` (`PERF203`) ([#12947](https://github.com/astral-sh/ruff/pull/12947))
-- \[`pydocstyle`\] Add reference to `lint.pydocstyle.ignore-decorators` setting to rule docs ([#12996](https://github.com/astral-sh/ruff/pull/12996))
-
 ## 0.6.1
 
 This is a hotfix release to address an issue with `ruff-pre-commit`. In v0.6,

CONTRIBUTING.md

@@ -397,18 +397,12 @@ which makes it a good target for benchmarking.
 git clone --branch 3.10 https://github.com/python/cpython.git crates/ruff_linter/resources/test/cpython
 ```
 
-Install `hyperfine`:
-
-```shell
-cargo install hyperfine
-```
-
 To benchmark the release build:
 
 ```shell
 cargo build --release && hyperfine --warmup 10 \
-  "./target/release/ruff check ./crates/ruff_linter/resources/test/cpython/ --no-cache -e" \
-  "./target/release/ruff check ./crates/ruff_linter/resources/test/cpython/ -e"
+  "./target/release/ruff ./crates/ruff_linter/resources/test/cpython/ --no-cache -e" \
+  "./target/release/ruff ./crates/ruff_linter/resources/test/cpython/ -e"
 
 Benchmark 1: ./target/release/ruff ./crates/ruff_linter/resources/test/cpython/ --no-cache
   Time (mean ± σ):     293.8 ms ±   3.2 ms    [User: 2384.6 ms, System: 90.3 ms]
@@ -427,7 +421,7 @@ To benchmark against the ecosystem's existing tools:
 
 ```shell
 hyperfine --ignore-failure --warmup 5 \
-  "./target/release/ruff check ./crates/ruff_linter/resources/test/cpython/ --no-cache" \
+  "./target/release/ruff ./crates/ruff_linter/resources/test/cpython/ --no-cache" \
   "pyflakes crates/ruff_linter/resources/test/cpython" \
   "autoflake --recursive --expand-star-imports --remove-all-unused-imports --remove-unused-variables --remove-duplicate-keys resources/test/cpython" \
   "pycodestyle crates/ruff_linter/resources/test/cpython" \
@@ -473,7 +467,7 @@ To benchmark a subset of rules, e.g. `LineTooLong` and `DocLineTooLong`:
 
 ```shell
 cargo build --release && hyperfine --warmup 10 \
-  "./target/release/ruff check ./crates/ruff_linter/resources/test/cpython/ --no-cache -e --select W505,E501"
+  "./target/release/ruff ./crates/ruff_linter/resources/test/cpython/ --no-cache -e --select W505,E501"
 ```
 
 You can run `poetry install` from `./scripts/benchmarks` to create a working environment for the

Cargo.lock

@@ -1935,7 +1935,6 @@ dependencies = [
  "smallvec",
  "static_assertions",
  "tempfile",
- "thiserror",
  "tracing",
  "walkdir",
  "zip",
@@ -1951,6 +1950,7 @@ dependencies = [
  "libc",
  "lsp-server",
  "lsp-types",
+ "red_knot_python_semantic",
  "red_knot_workspace",
  "ruff_db",
  "ruff_notebook",
@@ -1995,6 +1995,7 @@ dependencies = [
  "ruff_text_size",
  "rustc-hash 2.0.0",
  "salsa",
+ "thiserror",
  "tracing",
 ]
 
@@ -2088,7 +2089,7 @@ dependencies = [
 
 [[package]]
 name = "ruff"
-version = "0.6.2"
+version = "0.6.1"
 dependencies = [
  "anyhow",
  "argfile",
@@ -2280,7 +2281,7 @@ dependencies = [
 
 [[package]]
 name = "ruff_linter"
-version = "0.6.2"
+version = "0.6.1"
 dependencies = [
  "aho-corasick",
  "annotate-snippets 0.9.2",
@@ -2600,7 +2601,7 @@ dependencies = [
 
 [[package]]
 name = "ruff_wasm"
-version = "0.6.2"
+version = "0.6.1"
 dependencies = [
  "console_error_panic_hook",
  "console_log",

README.md

@@ -136,8 +136,8 @@ curl -LsSf https://astral.sh/ruff/install.sh | sh
 powershell -c "irm https://astral.sh/ruff/install.ps1 | iex"
 
 # For a specific version.
-curl -LsSf https://astral.sh/ruff/0.6.2/install.sh | sh
-powershell -c "irm https://astral.sh/ruff/0.6.2/install.ps1 | iex"
+curl -LsSf https://astral.sh/ruff/0.6.1/install.sh | sh
+powershell -c "irm https://astral.sh/ruff/0.6.1/install.ps1 | iex"
 ```
 
 You can also install Ruff via [Homebrew](https://formulae.brew.sh/formula/ruff), [Conda](https://anaconda.org/conda-forge/ruff),
@@ -170,7 +170,7 @@ Ruff can also be used as a [pre-commit](https://pre-commit.com/) hook via [`ruff
 ```yaml
 - repo: https://github.com/astral-sh/ruff-pre-commit
   # Ruff version.
-  rev: v0.6.2
+  rev: v0.6.1
   hooks:
     # Run the linter.
     - id: ruff

crates/red_knot/src/main.rs

@@ -7,12 +7,12 @@ use colored::Colorize;
 use crossbeam::channel as crossbeam_channel;
 use salsa::plumbing::ZalsaDatabase;
 
-use red_knot_python_semantic::SitePackages;
+use red_knot_python_semantic::{ProgramSettings, SearchPathSettings};
 use red_knot_server::run_server;
 use red_knot_workspace::db::RootDatabase;
+use red_knot_workspace::site_packages::VirtualEnvironment;
 use red_knot_workspace::watch;
 use red_knot_workspace::watch::WorkspaceWatcher;
-use red_knot_workspace::workspace::settings::Configuration;
 use red_knot_workspace::workspace::WorkspaceMetadata;
 use ruff_db::system::{OsSystem, System, SystemPath, SystemPathBuf};
 use target_version::TargetVersion;
@@ -65,14 +65,15 @@ to resolve type information for the project's third-party dependencies.",
         value_name = "PATH",
         help = "Additional path to use as a module-resolution source (can be passed multiple times)"
     )]
-    extra_search_path: Option<Vec<SystemPathBuf>>,
+    extra_search_path: Vec<SystemPathBuf>,
 
     #[arg(
         long,
         help = "Python version to assume when resolving types",
-        value_name = "VERSION"
-    )]
-    target_version: Option<TargetVersion>,
+        default_value_t = TargetVersion::default(),
+        value_name="VERSION")
+    ]
+    target_version: TargetVersion,
 
     #[clap(flatten)]
     verbosity: Verbosity,
@@ -85,36 +86,6 @@ to resolve type information for the project's third-party dependencies.",
     watch: bool,
 }
 
-impl Args {
-    fn to_configuration(&self, cli_cwd: &SystemPath) -> Configuration {
-        let mut configuration = Configuration::default();
-
-        if let Some(target_version) = self.target_version {
-            configuration.target_version = Some(target_version.into());
-        }
-
-        if let Some(venv_path) = &self.venv_path {
-            configuration.search_paths.site_packages = Some(SitePackages::Derived {
-                venv_path: SystemPath::absolute(venv_path, cli_cwd),
-            });
-        }
-
-        if let Some(custom_typeshed_dir) = &self.custom_typeshed_dir {
-            configuration.search_paths.custom_typeshed =
-                Some(SystemPath::absolute(custom_typeshed_dir, cli_cwd));
-        }
-
-        if let Some(extra_search_paths) = &self.extra_search_path {
-            configuration.search_paths.extra_paths = extra_search_paths
-                .iter()
-                .map(|path| Some(SystemPath::absolute(path, cli_cwd)))
-                .collect();
-        }
-
-        configuration
-    }
-}
-
 #[derive(Debug, clap::Subcommand)]
 pub enum Command {
     /// Start the language server
@@ -144,13 +115,22 @@ pub fn main() -> ExitStatus {
 }
 
 fn run() -> anyhow::Result<ExitStatus> {
-    let args = Args::parse_from(std::env::args().collect::<Vec<_>>());
+    let Args {
+        command,
+        current_directory,
+        custom_typeshed_dir,
+        extra_search_path: extra_paths,
+        venv_path,
+        target_version,
+        verbosity,
+        watch,
+    } = Args::parse_from(std::env::args().collect::<Vec<_>>());
 
-    if matches!(args.command, Some(Command::Server)) {
+    if matches!(command, Some(Command::Server)) {
         return run_server().map(|()| ExitStatus::Success);
     }
 
-    let verbosity = args.verbosity.level();
+    let verbosity = verbosity.level();
     countme::enable(verbosity.is_trace());
     let _guard = setup_tracing(verbosity)?;
 
@@ -166,12 +146,10 @@ fn run() -> anyhow::Result<ExitStatus> {
             })?
     };
 
-    let cwd = args
-        .current_directory
-        .as_ref()
+    let cwd = current_directory
         .map(|cwd| {
             if cwd.as_std_path().is_dir() {
-                Ok(SystemPath::absolute(cwd, &cli_base_path))
+                Ok(SystemPath::absolute(&cwd, &cli_base_path))
             } else {
                 Err(anyhow!(
                     "Provided current-directory path '{cwd}' is not a directory."
@@ -182,18 +160,33 @@ fn run() -> anyhow::Result<ExitStatus> {
         .unwrap_or_else(|| cli_base_path.clone());
 
     let system = OsSystem::new(cwd.clone());
-    let cli_configuration = args.to_configuration(&cwd);
-    let workspace_metadata = WorkspaceMetadata::from_path(
-        system.current_directory(),
-        &system,
-        Some(cli_configuration.clone()),
-    )?;
+    let workspace_metadata = WorkspaceMetadata::from_path(system.current_directory(), &system)?;
+
+    // TODO: Verify the remaining search path settings eagerly.
+    let site_packages = venv_path
+        .map(|path| {
+            VirtualEnvironment::new(path, &OsSystem::new(cli_base_path))
+                .and_then(|venv| venv.site_packages_directories(&system))
+        })
+        .transpose()?
+        .unwrap_or_default();
+
+    // TODO: Respect the settings from the workspace metadata. when resolving the program settings.
+    let program_settings = ProgramSettings {
+        target_version: target_version.into(),
+        search_paths: SearchPathSettings {
+            extra_paths,
+            src_root: workspace_metadata.root().to_path_buf(),
+            custom_typeshed: custom_typeshed_dir,
+            site_packages,
+        },
+    };
 
     // TODO: Use the `program_settings` to compute the key for the database's persistent
     //   cache and load the cache if it exists.
-    let mut db = RootDatabase::new(workspace_metadata, system)?;
+    let mut db = RootDatabase::new(workspace_metadata, program_settings, system)?;
 
-    let (main_loop, main_loop_cancellation_token) = MainLoop::new(cli_configuration);
+    let (main_loop, main_loop_cancellation_token) = MainLoop::new();
 
     // Listen to Ctrl+C and abort the watch mode.
     let main_loop_cancellation_token = Mutex::new(Some(main_loop_cancellation_token));
@@ -205,7 +198,7 @@ fn run() -> anyhow::Result<ExitStatus> {
         }
     })?;
 
-    let exit_status = if args.watch {
+    let exit_status = if watch {
         main_loop.watch(&mut db)?
     } else {
         main_loop.run(&mut db)
@@ -245,12 +238,10 @@ struct MainLoop {
 
     /// The file system watcher, if running in watch mode.
     watcher: Option<WorkspaceWatcher>,
-
-    cli_configuration: Configuration,
 }
 
 impl MainLoop {
-    fn new(cli_configuration: Configuration) -> (Self, MainLoopCancellationToken) {
+    fn new() -> (Self, MainLoopCancellationToken) {
         let (sender, receiver) = crossbeam_channel::bounded(10);
 
         (
@@ -258,7 +249,6 @@ impl MainLoop {
                 sender: sender.clone(),
                 receiver,
                 watcher: None,
-                cli_configuration,
             },
             MainLoopCancellationToken { sender },
         )
@@ -341,7 +331,7 @@ impl MainLoop {
                 MainLoopMessage::ApplyChanges(changes) => {
                     revision += 1;
                     // Automatically cancels any pending queries and waits for them to complete.
-                    db.apply_changes(changes, Some(&self.cli_configuration));
+                    db.apply_changes(changes);
                     if let Some(watcher) = self.watcher.as_mut() {
                         watcher.update(db);
                     }

crates/red_knot/tests/file_watching.rs

@@ -5,11 +5,12 @@ use std::time::Duration;
 
 use anyhow::{anyhow, Context};
 
-use red_knot_python_semantic::{resolve_module, ModuleName, Program, PythonVersion, SitePackages};
+use red_knot_python_semantic::{
+    resolve_module, ModuleName, Program, ProgramSettings, PythonVersion, SearchPathSettings,
+};
 use red_knot_workspace::db::RootDatabase;
 use red_knot_workspace::watch;
 use red_knot_workspace::watch::{directory_watcher, WorkspaceWatcher};
-use red_knot_workspace::workspace::settings::{Configuration, SearchPathConfiguration};
 use red_knot_workspace::workspace::WorkspaceMetadata;
 use ruff_db::files::{system_path_to_file, File, FileError};
 use ruff_db::source::source_text;
@@ -24,7 +25,7 @@ struct TestCase {
     /// We need to hold on to it in the test case or the temp files get deleted.
     _temp_dir: tempfile::TempDir,
     root_dir: SystemPathBuf,
-    configuration: Configuration,
+    search_path_settings: SearchPathSettings,
 }
 
 impl TestCase {
@@ -40,6 +41,10 @@ impl TestCase {
         &self.db
     }
 
+    fn db_mut(&mut self) -> &mut RootDatabase {
+        &mut self.db
+    }
+
     fn stop_watch(&mut self) -> Vec<watch::ChangeEvent> {
         self.try_stop_watch(Duration::from_secs(10))
             .expect("Expected watch changes but observed none.")
@@ -100,20 +105,16 @@ impl TestCase {
         Some(all_events)
     }
 
-    fn apply_changes(&mut self, changes: Vec<watch::ChangeEvent>) {
-        self.db.apply_changes(changes, Some(&self.configuration));
-    }
-
     fn update_search_path_settings(
         &mut self,
-        configuration: SearchPathConfiguration,
+        f: impl FnOnce(&SearchPathSettings) -> SearchPathSettings,
     ) -> anyhow::Result<()> {
         let program = Program::get(self.db());
 
-        self.configuration.search_paths = configuration.clone();
-        let new_settings = configuration.into_settings(self.db.workspace().root(&self.db));
+        let new_settings = f(&self.search_path_settings);
 
-        program.update_search_paths(&mut self.db, &new_settings)?;
+        program.update_search_paths(&mut self.db, new_settings.clone())?;
+        self.search_path_settings = new_settings;
 
         if let Some(watcher) = &mut self.watcher {
             watcher.update(&self.db);
@@ -178,14 +179,17 @@ fn setup<F>(setup_files: F) -> anyhow::Result<TestCase>
 where
     F: SetupFiles,
 {
-    setup_with_search_paths(setup_files, |_root, _workspace_path| {
-        SearchPathConfiguration::default()
+    setup_with_search_paths(setup_files, |_root, workspace_path| SearchPathSettings {
+        extra_paths: vec![],
+        src_root: workspace_path.to_path_buf(),
+        custom_typeshed: None,
+        site_packages: vec![],
     })
 }
 
 fn setup_with_search_paths<F>(
     setup_files: F,
-    create_search_paths: impl FnOnce(&SystemPath, &SystemPath) -> SearchPathConfiguration,
+    create_search_paths: impl FnOnce(&SystemPath, &SystemPath) -> SearchPathSettings,
 ) -> anyhow::Result<TestCase>
 where
     F: SetupFiles,
@@ -217,34 +221,25 @@ where
 
     let system = OsSystem::new(&workspace_path);
 
-    let search_paths = create_search_paths(&root_path, &workspace_path);
+    let workspace = WorkspaceMetadata::from_path(&workspace_path, &system)?;
+    let search_path_settings = create_search_paths(&root_path, workspace.root());
 
-    for path in search_paths
+    for path in search_path_settings
         .extra_paths
         .iter()
-        .flatten()
-        .chain(search_paths.custom_typeshed.iter())
-        .chain(search_paths.site_packages.iter().flat_map(|site_packages| {
-            if let SitePackages::Known(path) = site_packages {
-                path.as_slice()
-            } else {
-                &[]
-            }
-        }))
+        .chain(search_path_settings.site_packages.iter())
+        .chain(search_path_settings.custom_typeshed.iter())
     {
         std::fs::create_dir_all(path.as_std_path())
             .with_context(|| format!("Failed to create search path '{path}'"))?;
     }
 
-    let configuration = Configuration {
-        target_version: Some(PythonVersion::PY312),
-        search_paths,
+    let settings = ProgramSettings {
+        target_version: PythonVersion::default(),
+        search_paths: search_path_settings.clone(),
     };
 
-    let workspace =
-        WorkspaceMetadata::from_path(&workspace_path, &system, Some(configuration.clone()))?;
-
-    let db = RootDatabase::new(workspace, system)?;
+    let db = RootDatabase::new(workspace, settings, system)?;
 
     let (sender, receiver) = crossbeam::channel::unbounded();
     let watcher = directory_watcher(move |events| sender.send(events).unwrap())
@@ -259,7 +254,7 @@ where
         watcher: Some(watcher),
         _temp_dir: temp_dir,
         root_dir: root_path,
-        configuration,
+        search_path_settings,
     };
 
     // Sometimes the file watcher reports changes for events that happened before the watcher was started.
@@ -312,7 +307,7 @@ fn new_file() -> anyhow::Result<()> {
 
     let changes = case.stop_watch();
 
-    case.apply_changes(changes);
+    case.db_mut().apply_changes(changes);
 
     let foo = case.system_file(&foo_path).expect("foo.py to exist.");
 
@@ -335,7 +330,7 @@ fn new_ignored_file() -> anyhow::Result<()> {
 
     let changes = case.stop_watch();
 
-    case.apply_changes(changes);
+    case.db_mut().apply_changes(changes);
 
     assert!(case.system_file(&foo_path).is_ok());
     assert_eq!(&case.collect_package_files(&bar_path), &[bar_file]);
@@ -359,7 +354,7 @@ fn changed_file() -> anyhow::Result<()> {
 
     assert!(!changes.is_empty());
 
-    case.apply_changes(changes);
+    case.db_mut().apply_changes(changes);
 
     assert_eq!(source_text(case.db(), foo).as_str(), "print('Version 2')");
     assert_eq!(&case.collect_package_files(&foo_path), &[foo]);
@@ -382,7 +377,7 @@ fn deleted_file() -> anyhow::Result<()> {
 
     let changes = case.stop_watch();
 
-    case.apply_changes(changes);
+    case.db_mut().apply_changes(changes);
 
     assert!(!foo.exists(case.db()));
     assert_eq!(&case.collect_package_files(&foo_path), &[] as &[File]);
@@ -414,7 +409,7 @@ fn move_file_to_trash() -> anyhow::Result<()> {
 
     let changes = case.stop_watch();
 
-    case.apply_changes(changes);
+    case.db_mut().apply_changes(changes);
 
     assert!(!foo.exists(case.db()));
     assert_eq!(&case.collect_package_files(&foo_path), &[] as &[File]);
@@ -446,7 +441,7 @@ fn move_file_to_workspace() -> anyhow::Result<()> {
 
     let changes = case.stop_watch();
 
-    case.apply_changes(changes);
+    case.db_mut().apply_changes(changes);
 
     let foo_in_workspace = case.system_file(&foo_in_workspace_path)?;
 
@@ -474,7 +469,7 @@ fn rename_file() -> anyhow::Result<()> {
 
     let changes = case.stop_watch();
 
-    case.apply_changes(changes);
+    case.db_mut().apply_changes(changes);
 
     assert!(!foo.exists(case.db()));
 
@@ -515,7 +510,7 @@ fn directory_moved_to_workspace() -> anyhow::Result<()> {
 
     let changes = case.stop_watch();
 
-    case.apply_changes(changes);
+    case.db_mut().apply_changes(changes);
 
     let init_file = case
         .system_file(sub_new_path.join("__init__.py"))
@@ -566,7 +561,7 @@ fn directory_moved_to_trash() -> anyhow::Result<()> {
 
     let changes = case.stop_watch();
 
-    case.apply_changes(changes);
+    case.db_mut().apply_changes(changes);
 
     // `import sub.a` should no longer resolve
     assert!(resolve_module(case.db().upcast(), ModuleName::new_static("sub.a").unwrap()).is_none());
@@ -620,7 +615,7 @@ fn directory_renamed() -> anyhow::Result<()> {
 
     let changes = case.stop_watch();
 
-    case.apply_changes(changes);
+    case.db_mut().apply_changes(changes);
 
     // `import sub.a` should no longer resolve
     assert!(resolve_module(case.db().upcast(), ModuleName::new_static("sub.a").unwrap()).is_none());
@@ -685,7 +680,7 @@ fn directory_deleted() -> anyhow::Result<()> {
 
     let changes = case.stop_watch();
 
-    case.apply_changes(changes);
+    case.db_mut().apply_changes(changes);
 
     // `import sub.a` should no longer resolve
     assert!(resolve_module(case.db().upcast(), ModuleName::new_static("sub.a").unwrap()).is_none());
@@ -699,13 +694,15 @@ fn directory_deleted() -> anyhow::Result<()> {
 
 #[test]
 fn search_path() -> anyhow::Result<()> {
-    let mut case = setup_with_search_paths(
-        [("bar.py", "import sub.a")],
-        |root_path, _workspace_path| SearchPathConfiguration {
-            site_packages: Some(SitePackages::Known(vec![root_path.join("site_packages")])),
-            ..SearchPathConfiguration::default()
-        },
-    )?;
+    let mut case =
+        setup_with_search_paths([("bar.py", "import sub.a")], |root_path, workspace_path| {
+            SearchPathSettings {
+                extra_paths: vec![],
+                src_root: workspace_path.to_path_buf(),
+                custom_typeshed: None,
+                site_packages: vec![root_path.join("site_packages")],
+            }
+        })?;
 
     let site_packages = case.root_path().join("site_packages");
 
@@ -718,7 +715,7 @@ fn search_path() -> anyhow::Result<()> {
 
     let changes = case.stop_watch();
 
-    case.apply_changes(changes);
+    case.db_mut().apply_changes(changes);
 
     assert!(resolve_module(case.db().upcast(), ModuleName::new_static("a").unwrap()).is_some());
     assert_eq!(
@@ -739,9 +736,9 @@ fn add_search_path() -> anyhow::Result<()> {
     assert!(resolve_module(case.db().upcast(), ModuleName::new_static("a").unwrap()).is_none());
 
     // Register site-packages as a search path.
-    case.update_search_path_settings(SearchPathConfiguration {
-        site_packages: Some(SitePackages::Known(vec![site_packages.clone()])),
-        ..SearchPathConfiguration::default()
+    case.update_search_path_settings(|settings| SearchPathSettings {
+        site_packages: vec![site_packages.clone()],
+        ..settings.clone()
     })
     .expect("Search path settings to be valid");
 
@@ -749,7 +746,7 @@ fn add_search_path() -> anyhow::Result<()> {
 
     let changes = case.stop_watch();
 
-    case.apply_changes(changes);
+    case.db_mut().apply_changes(changes);
 
     assert!(resolve_module(case.db().upcast(), ModuleName::new_static("a").unwrap()).is_some());
 
@@ -758,19 +755,21 @@ fn add_search_path() -> anyhow::Result<()> {
 
 #[test]
 fn remove_search_path() -> anyhow::Result<()> {
-    let mut case = setup_with_search_paths(
-        [("bar.py", "import sub.a")],
-        |root_path, _workspace_path| SearchPathConfiguration {
-            site_packages: Some(SitePackages::Known(vec![root_path.join("site_packages")])),
-            ..SearchPathConfiguration::default()
-        },
-    )?;
+    let mut case =
+        setup_with_search_paths([("bar.py", "import sub.a")], |root_path, workspace_path| {
+            SearchPathSettings {
+                extra_paths: vec![],
+                src_root: workspace_path.to_path_buf(),
+                custom_typeshed: None,
+                site_packages: vec![root_path.join("site_packages")],
+            }
+        })?;
 
     // Remove site packages from the search path settings.
     let site_packages = case.root_path().join("site_packages");
-    case.update_search_path_settings(SearchPathConfiguration {
-        site_packages: None,
-        ..SearchPathConfiguration::default()
+    case.update_search_path_settings(|settings| SearchPathSettings {
+        site_packages: vec![],
+        ..settings.clone()
     })
     .expect("Search path settings to be valid");
 
@@ -783,48 +782,6 @@ fn remove_search_path() -> anyhow::Result<()> {
     Ok(())
 }
 
-#[test]
-fn changed_versions_file() -> anyhow::Result<()> {
-    let mut case = setup_with_search_paths(
-        |root_path: &SystemPath, workspace_path: &SystemPath| {
-            std::fs::write(workspace_path.join("bar.py").as_std_path(), "import sub.a")?;
-            std::fs::create_dir_all(root_path.join("typeshed/stdlib").as_std_path())?;
-            std::fs::write(root_path.join("typeshed/stdlib/VERSIONS").as_std_path(), "")?;
-            std::fs::write(
-                root_path.join("typeshed/stdlib/os.pyi").as_std_path(),
-                "# not important",
-            )?;
-
-            Ok(())
-        },
-        |root_path, _workspace_path| SearchPathConfiguration {
-            custom_typeshed: Some(root_path.join("typeshed")),
-            ..SearchPathConfiguration::default()
-        },
-    )?;
-
-    // Unset the custom typeshed directory.
-    assert_eq!(
-        resolve_module(case.db(), ModuleName::new("os").unwrap()),
-        None
-    );
-
-    std::fs::write(
-        case.root_path()
-            .join("typeshed/stdlib/VERSIONS")
-            .as_std_path(),
-        "os: 3.0-",
-    )?;
-
-    let changes = case.stop_watch();
-
-    case.apply_changes(changes);
-
-    assert!(resolve_module(case.db(), ModuleName::new("os").unwrap()).is_some());
-
-    Ok(())
-}
-
 /// Watch a workspace that contains two files where one file is a hardlink to another.
 ///
 /// Setup:
@@ -871,7 +828,7 @@ fn hard_links_in_workspace() -> anyhow::Result<()> {
 
     let changes = case.stop_watch();
 
-    case.apply_changes(changes);
+    case.db_mut().apply_changes(changes);
 
     assert_eq!(source_text(case.db(), foo).as_str(), "print('Version 2')");
 
@@ -942,7 +899,7 @@ fn hard_links_to_target_outside_workspace() -> anyhow::Result<()> {
 
     let changes = case.stop_watch();
 
-    case.apply_changes(changes);
+    case.db_mut().apply_changes(changes);
 
     assert_eq!(source_text(case.db(), bar).as_str(), "print('Version 2')");
 
@@ -981,7 +938,7 @@ mod unix {
 
         let changes = case.stop_watch();
 
-        case.apply_changes(changes);
+        case.db_mut().apply_changes(changes);
 
         assert_eq!(
             foo.permissions(case.db()),
@@ -1066,7 +1023,7 @@ mod unix {
 
         let changes = case.take_watch_changes();
 
-        case.apply_changes(changes);
+        case.db_mut().apply_changes(changes);
 
         assert_eq!(
             source_text(case.db(), baz.file()).as_str(),
@@ -1079,7 +1036,7 @@ mod unix {
 
         let changes = case.stop_watch();
 
-        case.apply_changes(changes);
+        case.db_mut().apply_changes(changes);
 
         assert_eq!(
             source_text(case.db(), baz.file()).as_str(),
@@ -1150,7 +1107,7 @@ mod unix {
 
         let changes = case.stop_watch();
 
-        case.apply_changes(changes);
+        case.db_mut().apply_changes(changes);
 
         // The file watcher is guaranteed to emit one event for the changed file, but it isn't specified
         // if the event is emitted for the "original" or linked path because both paths are watched.
@@ -1219,11 +1176,11 @@ mod unix {
 
                 Ok(())
             },
-            |_root, workspace| SearchPathConfiguration {
-                site_packages: Some(SitePackages::Known(vec![
-                    workspace.join(".venv/lib/python3.12/site-packages")
-                ])),
-                ..SearchPathConfiguration::default()
+            |_root, workspace| SearchPathSettings {
+                extra_paths: vec![],
+                src_root: workspace.to_path_buf(),
+                custom_typeshed: None,
+                site_packages: vec![workspace.join(".venv/lib/python3.12/site-packages")],
             },
         )?;
 
@@ -1258,7 +1215,7 @@ mod unix {
 
         let changes = case.stop_watch();
 
-        case.apply_changes(changes);
+        case.db_mut().apply_changes(changes);
 
         assert_eq!(
             source_text(case.db(), baz_original_file).as_str(),

crates/red_knot_python_semantic/Cargo.toml

@@ -26,7 +26,6 @@ countme = { workspace = true }
 once_cell = { workspace = true }
 ordermap = { workspace = true }
 salsa = { workspace = true }
-thiserror = { workspace = true }
 tracing = { workspace = true }
 rustc-hash = { workspace = true }
 hashbrown = { workspace = true }

crates/red_knot_python_semantic/src/lib.rs

@@ -5,7 +5,7 @@ use rustc_hash::FxHasher;
 pub use db::Db;
 pub use module_name::ModuleName;
 pub use module_resolver::{resolve_module, system_module_search_paths, vendored_typeshed_stubs};
-pub use program::{Program, ProgramSettings, SearchPathSettings, SitePackages};
+pub use program::{Program, ProgramSettings, SearchPathSettings};
 pub use python_version::PythonVersion;
 pub use semantic_model::{HasTy, SemanticModel};
 
@@ -19,7 +19,6 @@ mod program;
 mod python_version;
 pub mod semantic_index;
 mod semantic_model;
-pub(crate) mod site_packages;
 pub mod types;
 
 type FxOrderSet<V> = ordermap::set::OrderSet<V, BuildHasherDefault<FxHasher>>;

crates/red_knot_python_semantic/src/module_resolver/mod.rs

@@ -13,6 +13,7 @@ use resolver::SearchPathIterator;
 mod module;
 mod path;
 mod resolver;
+mod state;
 mod typeshed;
 
 #[cfg(test)]

crates/red_knot_python_semantic/src/module_resolver/path.rs

@@ -9,11 +9,11 @@ use ruff_db::files::{system_path_to_file, vendored_path_to_file, File, FileError
 use ruff_db::system::{System, SystemPath, SystemPathBuf};
 use ruff_db::vendored::{VendoredPath, VendoredPathBuf};
 
-use super::typeshed::{typeshed_versions, TypeshedVersionsParseError, TypeshedVersionsQueryResult};
 use crate::db::Db;
 use crate::module_name::ModuleName;
-use crate::module_resolver::resolver::ResolverContext;
-use crate::site_packages::SitePackagesDiscoveryError;
+
+use super::state::ResolverState;
+use super::typeshed::{TypeshedVersionsParseError, TypeshedVersionsQueryResult};
 
 /// A path that points to a Python module.
 ///
@@ -60,7 +60,7 @@ impl ModulePath {
     }
 
     #[must_use]
-    pub(super) fn is_directory(&self, resolver: &ResolverContext) -> bool {
+    pub(crate) fn is_directory(&self, resolver: &ResolverState) -> bool {
         let ModulePath {
             search_path,
             relative_path,
@@ -74,7 +74,7 @@ impl ModulePath {
                     == Err(FileError::IsADirectory)
             }
             SearchPathInner::StandardLibraryCustom(stdlib_root) => {
-                match query_stdlib_version(relative_path, resolver) {
+                match query_stdlib_version(Some(stdlib_root), relative_path, resolver) {
                     TypeshedVersionsQueryResult::DoesNotExist => false,
                     TypeshedVersionsQueryResult::Exists
                     | TypeshedVersionsQueryResult::MaybeExists => {
@@ -84,7 +84,7 @@ impl ModulePath {
                 }
             }
             SearchPathInner::StandardLibraryVendored(stdlib_root) => {
-                match query_stdlib_version(relative_path, resolver) {
+                match query_stdlib_version(None, relative_path, resolver) {
                     TypeshedVersionsQueryResult::DoesNotExist => false,
                     TypeshedVersionsQueryResult::Exists
                     | TypeshedVersionsQueryResult::MaybeExists => resolver
@@ -96,7 +96,7 @@ impl ModulePath {
     }
 
     #[must_use]
-    pub(super) fn is_regular_package(&self, resolver: &ResolverContext) -> bool {
+    pub(crate) fn is_regular_package(&self, resolver: &ResolverState) -> bool {
         let ModulePath {
             search_path,
             relative_path,
@@ -113,7 +113,7 @@ impl ModulePath {
                         .is_ok()
             }
             SearchPathInner::StandardLibraryCustom(search_path) => {
-                match query_stdlib_version(relative_path, resolver) {
+                match query_stdlib_version(Some(search_path), relative_path, resolver) {
                     TypeshedVersionsQueryResult::DoesNotExist => false,
                     TypeshedVersionsQueryResult::Exists
                     | TypeshedVersionsQueryResult::MaybeExists => system_path_to_file(
@@ -124,7 +124,7 @@ impl ModulePath {
                 }
             }
             SearchPathInner::StandardLibraryVendored(search_path) => {
-                match query_stdlib_version(relative_path, resolver) {
+                match query_stdlib_version(None, relative_path, resolver) {
                     TypeshedVersionsQueryResult::DoesNotExist => false,
                     TypeshedVersionsQueryResult::Exists
                     | TypeshedVersionsQueryResult::MaybeExists => resolver
@@ -136,7 +136,7 @@ impl ModulePath {
     }
 
     #[must_use]
-    pub(super) fn to_file(&self, resolver: &ResolverContext) -> Option<File> {
+    pub(crate) fn to_file(&self, resolver: &ResolverState) -> Option<File> {
         let db = resolver.db.upcast();
         let ModulePath {
             search_path,
@@ -150,7 +150,7 @@ impl ModulePath {
                 system_path_to_file(db, search_path.join(relative_path)).ok()
             }
             SearchPathInner::StandardLibraryCustom(stdlib_root) => {
-                match query_stdlib_version(relative_path, resolver) {
+                match query_stdlib_version(Some(stdlib_root), relative_path, resolver) {
                     TypeshedVersionsQueryResult::DoesNotExist => None,
                     TypeshedVersionsQueryResult::Exists
                     | TypeshedVersionsQueryResult::MaybeExists => {
@@ -159,7 +159,7 @@ impl ModulePath {
                 }
             }
             SearchPathInner::StandardLibraryVendored(stdlib_root) => {
-                match query_stdlib_version(relative_path, resolver) {
+                match query_stdlib_version(None, relative_path, resolver) {
                     TypeshedVersionsQueryResult::DoesNotExist => None,
                     TypeshedVersionsQueryResult::Exists
                     | TypeshedVersionsQueryResult::MaybeExists => {
@@ -273,15 +273,19 @@ fn stdlib_path_to_module_name(relative_path: &Utf8Path) -> Option<ModuleName> {
 
 #[must_use]
 fn query_stdlib_version(
+    custom_stdlib_root: Option<&SystemPath>,
     relative_path: &Utf8Path,
-    context: &ResolverContext,
+    resolver: &ResolverState,
 ) -> TypeshedVersionsQueryResult {
     let Some(module_name) = stdlib_path_to_module_name(relative_path) else {
         return TypeshedVersionsQueryResult::DoesNotExist;
     };
-    let ResolverContext { db, target_version } = context;
-
-    typeshed_versions(*db).query_module(&module_name, *target_version)
+    let ResolverState {
+        db,
+        typeshed_versions,
+        target_version,
+    } = resolver;
+    typeshed_versions.query_module(*db, &module_name, custom_stdlib_root, *target_version)
 }
 
 /// Enumeration describing the various ways in which validation of a search path might fail.
@@ -289,7 +293,7 @@ fn query_stdlib_version(
 /// If validation fails for a search path derived from the user settings,
 /// a message must be displayed to the user,
 /// as type checking cannot be done reliably in these circumstances.
-#[derive(Debug)]
+#[derive(Debug, PartialEq, Eq)]
 pub(crate) enum SearchPathValidationError {
     /// The path provided by the user was not a directory
     NotADirectory(SystemPathBuf),
@@ -300,20 +304,18 @@ pub(crate) enum SearchPathValidationError {
     NoStdlibSubdirectory(SystemPathBuf),
 
     /// The typeshed path provided by the user is a directory,
-    /// but `stdlib/VERSIONS` could not be read.
+    /// but no `stdlib/VERSIONS` file exists.
     /// (This is only relevant for stdlib search paths.)
-    FailedToReadVersionsFile {
-        path: SystemPathBuf,
-        error: std::io::Error,
-    },
+    NoVersionsFile(SystemPathBuf),
+
+    /// `stdlib/VERSIONS` is a directory.
+    /// (This is only relevant for stdlib search paths.)
+    VersionsIsADirectory(SystemPathBuf),
 
     /// The path provided by the user is a directory,
     /// and a `stdlib/VERSIONS` file exists, but it fails to parse.
     /// (This is only relevant for stdlib search paths.)
     VersionsParseError(TypeshedVersionsParseError),
-
-    /// Failed to discover the site-packages for the configured virtual environment.
-    SitePackagesDiscovery(SitePackagesDiscoveryError),
 }
 
 impl fmt::Display for SearchPathValidationError {
@@ -323,16 +325,9 @@ impl fmt::Display for SearchPathValidationError {
             Self::NoStdlibSubdirectory(path) => {
                 write!(f, "The directory at {path} has no `stdlib/` subdirectory")
             }
-            Self::FailedToReadVersionsFile { path, error } => {
-                write!(
-                    f,
-                    "Failed to read the custom typeshed versions file '{path}': {error}"
-                )
-            }
+            Self::NoVersionsFile(path) => write!(f, "Expected a file at {path}/stdlib/VERSIONS"),
+            Self::VersionsIsADirectory(path) => write!(f, "{path}/stdlib/VERSIONS is a directory."),
             Self::VersionsParseError(underlying_error) => underlying_error.fmt(f),
-            SearchPathValidationError::SitePackagesDiscovery(error) => {
-                write!(f, "Failed to discover the site-packages directory: {error}")
-            }
         }
     }
 }
@@ -347,18 +342,6 @@ impl std::error::Error for SearchPathValidationError {
     }
 }
 
-impl From<TypeshedVersionsParseError> for SearchPathValidationError {
-    fn from(value: TypeshedVersionsParseError) -> Self {
-        Self::VersionsParseError(value)
-    }
-}
-
-impl From<SitePackagesDiscoveryError> for SearchPathValidationError {
-    fn from(value: SitePackagesDiscoveryError) -> Self {
-        Self::SitePackagesDiscovery(value)
-    }
-}
-
 type SearchPathResult<T> = Result<T, SearchPathValidationError>;
 
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
@@ -401,10 +384,11 @@ pub(crate) struct SearchPath(Arc<SearchPathInner>);
 
 impl SearchPath {
     fn directory_path(system: &dyn System, root: SystemPathBuf) -> SearchPathResult<SystemPathBuf> {
-        if system.is_directory(&root) {
-            Ok(root)
+        let canonicalized = system.canonicalize_path(&root).unwrap_or(root);
+        if system.is_directory(&canonicalized) {
+            Ok(canonicalized)
         } else {
-            Err(SearchPathValidationError::NotADirectory(root))
+            Err(SearchPathValidationError::NotADirectory(canonicalized))
         }
     }
 
@@ -423,22 +407,32 @@ impl SearchPath {
     }
 
     /// Create a new standard-library search path pointing to a custom directory on disk
-    pub(crate) fn custom_stdlib(db: &dyn Db, typeshed: &SystemPath) -> SearchPathResult<Self> {
+    pub(crate) fn custom_stdlib(db: &dyn Db, typeshed: SystemPathBuf) -> SearchPathResult<Self> {
         let system = db.system();
-        if !system.is_directory(typeshed) {
+        if !system.is_directory(&typeshed) {
             return Err(SearchPathValidationError::NotADirectory(
                 typeshed.to_path_buf(),
             ));
         }
-
         let stdlib =
             Self::directory_path(system, typeshed.join("stdlib")).map_err(|err| match err {
-                SearchPathValidationError::NotADirectory(_) => {
-                    SearchPathValidationError::NoStdlibSubdirectory(typeshed.to_path_buf())
+                SearchPathValidationError::NotADirectory(path) => {
+                    SearchPathValidationError::NoStdlibSubdirectory(path)
                 }
                 err => err,
             })?;
-
+        let typeshed_versions =
+            system_path_to_file(db.upcast(), stdlib.join("VERSIONS")).map_err(|err| match err {
+                FileError::NotFound => SearchPathValidationError::NoVersionsFile(typeshed),
+                FileError::IsADirectory => {
+                    SearchPathValidationError::VersionsIsADirectory(typeshed)
+                }
+            })?;
+        super::typeshed::parse_typeshed_versions(db, typeshed_versions)
+            .as_ref()
+            .map_err(|validation_error| {
+                SearchPathValidationError::VersionsParseError(validation_error.clone())
+            })?;
         Ok(Self(Arc::new(SearchPathInner::StandardLibraryCustom(
             stdlib,
         ))))
@@ -629,10 +623,10 @@ mod tests {
     use ruff_db::Db;
 
     use crate::db::tests::TestDb;
-    use crate::module_resolver::testing::{FileSpec, MockedTypeshed, TestCase, TestCaseBuilder};
-    use crate::python_version::PythonVersion;
 
     use super::*;
+    use crate::module_resolver::testing::{FileSpec, MockedTypeshed, TestCase, TestCaseBuilder};
+    use crate::python_version::PythonVersion;
 
     impl ModulePath {
         #[must_use]
@@ -644,6 +638,15 @@ mod tests {
     }
 
     impl SearchPath {
+        #[must_use]
+        pub(crate) fn is_stdlib_search_path(&self) -> bool {
+            matches!(
+                &*self.0,
+                SearchPathInner::StandardLibraryCustom(_)
+                    | SearchPathInner::StandardLibraryVendored(_)
+            )
+        }
+
         fn join(&self, component: &str) -> ModulePath {
             self.to_module_path().join(component)
         }
@@ -658,7 +661,7 @@ mod tests {
             .build();
 
         assert_eq!(
-            SearchPath::custom_stdlib(&db, stdlib.parent().unwrap())
+            SearchPath::custom_stdlib(&db, stdlib.parent().unwrap().to_path_buf())
                 .unwrap()
                 .to_module_path()
                 .with_py_extension(),
@@ -666,7 +669,7 @@ mod tests {
         );
 
         assert_eq!(
-            &SearchPath::custom_stdlib(&db, stdlib.parent().unwrap())
+            &SearchPath::custom_stdlib(&db, stdlib.parent().unwrap().to_path_buf())
                 .unwrap()
                 .join("foo")
                 .with_pyi_extension(),
@@ -777,7 +780,7 @@ mod tests {
         let TestCase { db, stdlib, .. } = TestCaseBuilder::new()
             .with_custom_typeshed(MockedTypeshed::default())
             .build();
-        SearchPath::custom_stdlib(&db, stdlib.parent().unwrap())
+        SearchPath::custom_stdlib(&db, stdlib.parent().unwrap().to_path_buf())
             .unwrap()
             .to_module_path()
             .push("bar.py");
@@ -789,7 +792,7 @@ mod tests {
         let TestCase { db, stdlib, .. } = TestCaseBuilder::new()
             .with_custom_typeshed(MockedTypeshed::default())
             .build();
-        SearchPath::custom_stdlib(&db, stdlib.parent().unwrap())
+        SearchPath::custom_stdlib(&db, stdlib.parent().unwrap().to_path_buf())
             .unwrap()
             .to_module_path()
             .push("bar.rs");
@@ -821,7 +824,7 @@ mod tests {
             .with_custom_typeshed(MockedTypeshed::default())
             .build();
 
-        let root = SearchPath::custom_stdlib(&db, stdlib.parent().unwrap()).unwrap();
+        let root = SearchPath::custom_stdlib(&db, stdlib.parent().unwrap().to_path_buf()).unwrap();
 
         // Must have a `.pyi` extension or no extension:
         let bad_absolute_path = SystemPath::new("foo/stdlib/x.py");
@@ -869,7 +872,8 @@ mod tests {
             .with_custom_typeshed(typeshed)
             .with_target_version(target_version)
             .build();
-        let stdlib = SearchPath::custom_stdlib(&db, stdlib.parent().unwrap()).unwrap();
+        let stdlib =
+            SearchPath::custom_stdlib(&db, stdlib.parent().unwrap().to_path_buf()).unwrap();
         (db, stdlib)
     }
 
@@ -894,7 +898,7 @@ mod tests {
         };
 
         let (db, stdlib_path) = py38_typeshed_test_case(TYPESHED);
-        let resolver = ResolverContext::new(&db, PythonVersion::PY38);
+        let resolver = ResolverState::new(&db, PythonVersion::PY38);
 
         let asyncio_regular_package = stdlib_path.join("asyncio");
         assert!(asyncio_regular_package.is_directory(&resolver));
@@ -922,7 +926,7 @@ mod tests {
         };
 
         let (db, stdlib_path) = py38_typeshed_test_case(TYPESHED);
-        let resolver = ResolverContext::new(&db, PythonVersion::PY38);
+        let resolver = ResolverState::new(&db, PythonVersion::PY38);
 
         let xml_namespace_package = stdlib_path.join("xml");
         assert!(xml_namespace_package.is_directory(&resolver));
@@ -944,7 +948,7 @@ mod tests {
         };
 
         let (db, stdlib_path) = py38_typeshed_test_case(TYPESHED);
-        let resolver = ResolverContext::new(&db, PythonVersion::PY38);
+        let resolver = ResolverState::new(&db, PythonVersion::PY38);
 
         let functools_module = stdlib_path.join("functools.pyi");
         assert!(functools_module.to_file(&resolver).is_some());
@@ -960,7 +964,7 @@ mod tests {
         };
 
         let (db, stdlib_path) = py38_typeshed_test_case(TYPESHED);
-        let resolver = ResolverContext::new(&db, PythonVersion::PY38);
+        let resolver = ResolverState::new(&db, PythonVersion::PY38);
 
         let collections_regular_package = stdlib_path.join("collections");
         assert_eq!(collections_regular_package.to_file(&resolver), None);
@@ -976,7 +980,7 @@ mod tests {
         };
 
         let (db, stdlib_path) = py38_typeshed_test_case(TYPESHED);
-        let resolver = ResolverContext::new(&db, PythonVersion::PY38);
+        let resolver = ResolverState::new(&db, PythonVersion::PY38);
 
         let importlib_namespace_package = stdlib_path.join("importlib");
         assert_eq!(importlib_namespace_package.to_file(&resolver), None);
@@ -997,7 +1001,7 @@ mod tests {
         };
 
         let (db, stdlib_path) = py38_typeshed_test_case(TYPESHED);
-        let resolver = ResolverContext::new(&db, PythonVersion::PY38);
+        let resolver = ResolverState::new(&db, PythonVersion::PY38);
 
         let non_existent = stdlib_path.join("doesnt_even_exist");
         assert_eq!(non_existent.to_file(&resolver), None);
@@ -1025,7 +1029,7 @@ mod tests {
         };
 
         let (db, stdlib_path) = py39_typeshed_test_case(TYPESHED);
-        let resolver = ResolverContext::new(&db, PythonVersion::PY39);
+        let resolver = ResolverState::new(&db, PythonVersion::PY39);
 
         // Since we've set the target version to Py39,
         // `collections` should now exist as a directory, according to VERSIONS...
@@ -1054,7 +1058,7 @@ mod tests {
         };
 
         let (db, stdlib_path) = py39_typeshed_test_case(TYPESHED);
-        let resolver = ResolverContext::new(&db, PythonVersion::PY39);
+        let resolver = ResolverState::new(&db, PythonVersion::PY39);
 
         // The `importlib` directory now also exists
         let importlib_namespace_package = stdlib_path.join("importlib");
@@ -1078,7 +1082,7 @@ mod tests {
         };
 
         let (db, stdlib_path) = py39_typeshed_test_case(TYPESHED);
-        let resolver = ResolverContext::new(&db, PythonVersion::PY39);
+        let resolver = ResolverState::new(&db, PythonVersion::PY39);
 
         // The `xml` package no longer exists on py39:
         let xml_namespace_package = stdlib_path.join("xml");

crates/red_knot_python_semantic/src/module_resolver/resolver.rs

@@ -1,19 +1,19 @@
-use rustc_hash::{FxBuildHasher, FxHashSet};
 use std::borrow::Cow;
 use std::iter::FusedIterator;
-use std::ops::Deref;
+
+use rustc_hash::{FxBuildHasher, FxHashSet};
 
 use ruff_db::files::{File, FilePath, FileRootKind};
-use ruff_db::system::{DirectoryEntry, System, SystemPath, SystemPathBuf};
-use ruff_db::vendored::{VendoredFileSystem, VendoredPath};
+use ruff_db::system::{DirectoryEntry, SystemPath, SystemPathBuf};
+use ruff_db::vendored::VendoredPath;
+
+use crate::db::Db;
+use crate::module_name::ModuleName;
+use crate::{Program, SearchPathSettings};
 
 use super::module::{Module, ModuleKind};
 use super::path::{ModulePath, SearchPath, SearchPathValidationError};
-use crate::db::Db;
-use crate::module_name::ModuleName;
-use crate::module_resolver::typeshed::{vendored_typeshed_versions, TypeshedVersions};
-use crate::site_packages::VirtualEnvironment;
-use crate::{Program, PythonVersion, SearchPathSettings, SitePackages};
+use super::state::ResolverState;
 
 /// Resolves a module name to a module.
 pub fn resolve_module(db: &dyn Db, module_name: ModuleName) -> Option<Module> {
@@ -122,7 +122,7 @@ pub(crate) fn search_paths(db: &dyn Db) -> SearchPathIterator {
     Program::get(db).search_paths(db).iter(db)
 }
 
-#[derive(Debug, PartialEq, Eq)]
+#[derive(Debug, PartialEq, Eq, Default)]
 pub(crate) struct SearchPaths {
     /// Search paths that have been statically determined purely from reading Ruff's configuration settings.
     /// These shouldn't ever change unless the config settings themselves change.
@@ -135,8 +135,6 @@ pub(crate) struct SearchPaths {
     /// in terms of module-resolution priority until we've discovered the editable installs
     /// for the first `site-packages` path
     site_packages: Vec<SearchPath>,
-
-    typeshed_versions: ResolvedTypeshedVersions,
 }
 
 impl SearchPaths {
@@ -148,14 +146,8 @@ impl SearchPaths {
     /// [module resolution order]: https://typing.readthedocs.io/en/latest/spec/distributing.html#import-resolution-ordering
     pub(crate) fn from_settings(
         db: &dyn Db,
-        settings: &SearchPathSettings,
+        settings: SearchPathSettings,
     ) -> Result<Self, SearchPathValidationError> {
-        fn canonicalize(path: &SystemPath, system: &dyn System) -> SystemPathBuf {
-            system
-                .canonicalize_path(path)
-                .unwrap_or_else(|_| path.to_path_buf())
-        }
-
         let SearchPathSettings {
             extra_paths,
             src_root,
@@ -169,65 +161,45 @@ impl SearchPaths {
         let mut static_paths = vec![];
 
         for path in extra_paths {
-            let path = canonicalize(path, system);
-            files.try_add_root(db.upcast(), &path, FileRootKind::LibrarySearchPath);
-            tracing::debug!("Adding extra search-path '{path}'");
+            tracing::debug!("Adding static extra search-path '{path}'");
 
-            static_paths.push(SearchPath::extra(system, path)?);
+            let search_path = SearchPath::extra(system, path)?;
+            files.try_add_root(
+                db.upcast(),
+                search_path.as_system_path().unwrap(),
+                FileRootKind::LibrarySearchPath,
+            );
+            static_paths.push(search_path);
         }
 
         tracing::debug!("Adding first-party search path '{src_root}'");
-        static_paths.push(SearchPath::first_party(system, src_root.to_path_buf())?);
+        static_paths.push(SearchPath::first_party(system, src_root)?);
 
-        let (typeshed_versions, stdlib_path) = if let Some(custom_typeshed) = custom_typeshed {
-            let custom_typeshed = canonicalize(custom_typeshed, system);
+        static_paths.push(if let Some(custom_typeshed) = custom_typeshed {
             tracing::debug!("Adding custom-stdlib search path '{custom_typeshed}'");
 
+            let search_path = SearchPath::custom_stdlib(db, custom_typeshed)?;
             files.try_add_root(
                 db.upcast(),
-                &custom_typeshed,
+                search_path.as_system_path().unwrap(),
                 FileRootKind::LibrarySearchPath,
             );
-
-            let versions_path = custom_typeshed.join("stdlib/VERSIONS");
-
-            let versions_content = system.read_to_string(&versions_path).map_err(|error| {
-                SearchPathValidationError::FailedToReadVersionsFile {
-                    path: versions_path,
-                    error,
-                }
-            })?;
-
-            let parsed: TypeshedVersions = versions_content.parse()?;
-
-            let search_path = SearchPath::custom_stdlib(db, &custom_typeshed)?;
-
-            (ResolvedTypeshedVersions::Custom(parsed), search_path)
+            search_path
         } else {
-            tracing::debug!("Using vendored stdlib");
-            (
-                ResolvedTypeshedVersions::Vendored(vendored_typeshed_versions()),
-                SearchPath::vendored_stdlib(),
-            )
-        };
-
-        static_paths.push(stdlib_path);
-
-        let site_packages_paths = match site_packages_paths {
-            SitePackages::Derived { venv_path } => VirtualEnvironment::new(venv_path, system)
-                .and_then(|venv| venv.site_packages_directories(system))?,
-            SitePackages::Known(paths) => paths
-                .iter()
-                .map(|path| canonicalize(path, system))
-                .collect(),
-        };
+            SearchPath::vendored_stdlib()
+        });
 
         let mut site_packages: Vec<_> = Vec::with_capacity(site_packages_paths.len());
 
         for path in site_packages_paths {
             tracing::debug!("Adding site-packages search path '{path}'");
-            files.try_add_root(db.upcast(), &path, FileRootKind::LibrarySearchPath);
-            site_packages.push(SearchPath::site_packages(system, path)?);
+            let search_path = SearchPath::site_packages(system, path)?;
+            files.try_add_root(
+                db.upcast(),
+                search_path.as_system_path().unwrap(),
+                FileRootKind::LibrarySearchPath,
+            );
+            site_packages.push(search_path);
         }
 
         // TODO vendor typeshed's third-party stubs as well as the stdlib and fallback to them as a final step
@@ -252,48 +224,16 @@ impl SearchPaths {
         Ok(SearchPaths {
             static_paths,
             site_packages,
-            typeshed_versions,
         })
     }
 
-    pub(super) fn iter<'a>(&'a self, db: &'a dyn Db) -> SearchPathIterator<'a> {
+    pub(crate) fn iter<'a>(&'a self, db: &'a dyn Db) -> SearchPathIterator<'a> {
         SearchPathIterator {
             db,
             static_paths: self.static_paths.iter(),
             dynamic_paths: None,
         }
     }
-
-    pub(crate) fn custom_stdlib(&self) -> Option<&SystemPath> {
-        self.static_paths.iter().find_map(|search_path| {
-            if search_path.is_standard_library() {
-                search_path.as_system_path()
-            } else {
-                None
-            }
-        })
-    }
-
-    pub(super) fn typeshed_versions(&self) -> &TypeshedVersions {
-        &self.typeshed_versions
-    }
-}
-
-#[derive(Debug, PartialEq, Eq)]
-enum ResolvedTypeshedVersions {
-    Vendored(&'static TypeshedVersions),
-    Custom(TypeshedVersions),
-}
-
-impl Deref for ResolvedTypeshedVersions {
-    type Target = TypeshedVersions;
-
-    fn deref(&self) -> &Self::Target {
-        match self {
-            ResolvedTypeshedVersions::Vendored(versions) => versions,
-            ResolvedTypeshedVersions::Custom(versions) => versions,
-        }
-    }
 }
 
 /// Collect all dynamic search paths. For each `site-packages` path:
@@ -311,7 +251,6 @@ pub(crate) fn dynamic_resolution_paths(db: &dyn Db) -> Vec<SearchPath> {
     let SearchPaths {
         static_paths,
         site_packages,
-        typeshed_versions: _,
     } = Program::get(db).search_paths(db);
 
     let mut dynamic_paths = Vec::new();
@@ -376,16 +315,12 @@ pub(crate) fn dynamic_resolution_paths(db: &dyn Db) -> Vec<SearchPath> {
         let installations = all_pth_files.iter().flat_map(PthFile::items);
 
         for installation in installations {
-            let installation = system
-                .canonicalize_path(&installation)
-                .unwrap_or(installation);
-
             if existing_paths.insert(Cow::Owned(installation.clone())) {
-                match SearchPath::editable(system, installation.clone()) {
+                match SearchPath::editable(system, installation) {
                     Ok(search_path) => {
                         tracing::debug!(
                             "Adding editable installation to module resolution path {path}",
-                            path = installation
+                            path = search_path.as_system_path().unwrap()
                         );
                         dynamic_paths.push(search_path);
                     }
@@ -547,7 +482,7 @@ struct ModuleNameIngredient<'db> {
 fn resolve_name(db: &dyn Db, name: &ModuleName) -> Option<(SearchPath, File, ModuleKind)> {
     let program = Program::get(db);
     let target_version = program.target_version(db);
-    let resolver_state = ResolverContext::new(db, target_version);
+    let resolver_state = ResolverState::new(db, target_version);
     let is_builtin_module =
         ruff_python_stdlib::sys::is_builtin_module(target_version.minor, name.as_str());
 
@@ -610,7 +545,7 @@ fn resolve_name(db: &dyn Db, name: &ModuleName) -> Option<(SearchPath, File, Mod
 fn resolve_package<'a, 'db, I>(
     module_search_path: &SearchPath,
     components: I,
-    resolver_state: &ResolverContext<'db>,
+    resolver_state: &ResolverState<'db>,
 ) -> Result<ResolvedPackage, PackageKind>
 where
     I: Iterator<Item = &'a str>,
@@ -692,21 +627,6 @@ impl PackageKind {
     }
 }
 
-pub(super) struct ResolverContext<'db> {
-    pub(super) db: &'db dyn Db,
-    pub(super) target_version: PythonVersion,
-}
-
-impl<'db> ResolverContext<'db> {
-    pub(super) fn new(db: &'db dyn Db, target_version: PythonVersion) -> Self {
-        Self { db, target_version }
-    }
-
-    pub(super) fn vendored(&self) -> &VendoredFileSystem {
-        self.db.vendored()
-    }
-}
-
 #[cfg(test)]
 mod tests {
     use ruff_db::files::{system_path_to_file, File, FilePath};
@@ -861,7 +781,7 @@ mod tests {
                 "Search path for {module_name} was unexpectedly {search_path:?}"
             );
             assert!(
-                search_path.is_standard_library(),
+                search_path.is_stdlib_search_path(),
                 "Expected a stdlib search path, but got {search_path:?}"
             );
         }
@@ -957,7 +877,7 @@ mod tests {
                 "Search path for {module_name} was unexpectedly {search_path:?}"
             );
             assert!(
-                search_path.is_standard_library(),
+                search_path.is_stdlib_search_path(),
                 "Expected a stdlib search path, but got {search_path:?}"
             );
         }
@@ -1274,13 +1194,13 @@ mod tests {
 
         Program::from_settings(
             &db,
-            &ProgramSettings {
+            ProgramSettings {
                 target_version: PythonVersion::PY38,
                 search_paths: SearchPathSettings {
                     extra_paths: vec![],
                     src_root: src.clone(),
                     custom_typeshed: Some(custom_typeshed.clone()),
-                    site_packages: SitePackages::Known(vec![site_packages]),
+                    site_packages: vec![site_packages],
                 },
             },
         )
@@ -1779,16 +1699,13 @@ not_a_directory
 
         Program::from_settings(
             &db,
-            &ProgramSettings {
+            ProgramSettings {
                 target_version: PythonVersion::default(),
                 search_paths: SearchPathSettings {
                     extra_paths: vec![],
                     src_root: SystemPathBuf::from("/src"),
                     custom_typeshed: None,
-                    site_packages: SitePackages::Known(vec![
-                        venv_site_packages,
-                        system_site_packages,
-                    ]),
+                    site_packages: vec![venv_site_packages, system_site_packages],
                 },
             },
         )

crates/red_knot_python_semantic/src/module_resolver/state.rs

@@ -0,0 +1,25 @@
+use ruff_db::vendored::VendoredFileSystem;
+
+use super::typeshed::LazyTypeshedVersions;
+use crate::db::Db;
+use crate::python_version::PythonVersion;
+
+pub(crate) struct ResolverState<'db> {
+    pub(crate) db: &'db dyn Db,
+    pub(crate) typeshed_versions: LazyTypeshedVersions<'db>,
+    pub(crate) target_version: PythonVersion,
+}
+
+impl<'db> ResolverState<'db> {
+    pub(crate) fn new(db: &'db dyn Db, target_version: PythonVersion) -> Self {
+        Self {
+            db,
+            typeshed_versions: LazyTypeshedVersions::new(),
+            target_version,
+        }
+    }
+
+    pub(crate) fn vendored(&self) -> &VendoredFileSystem {
+        self.db.vendored()
+    }
+}

crates/red_knot_python_semantic/src/module_resolver/testing.rs

@@ -4,7 +4,7 @@ use ruff_db::vendored::VendoredPathBuf;
 use crate::db::tests::TestDb;
 use crate::program::{Program, SearchPathSettings};
 use crate::python_version::PythonVersion;
-use crate::{ProgramSettings, SitePackages};
+use crate::ProgramSettings;
 
 /// A test case for the module resolver.
 ///
@@ -179,7 +179,6 @@ impl TestCaseBuilder<UnspecifiedTypeshed> {
             first_party_files,
             site_packages_files,
         } = self;
-
         TestCaseBuilder {
             typeshed_option: typeshed,
             target_version,
@@ -196,7 +195,6 @@ impl TestCaseBuilder<UnspecifiedTypeshed> {
             site_packages,
             target_version,
         } = self.with_custom_typeshed(MockedTypeshed::default()).build();
-
         TestCase {
             db,
             src,
@@ -225,13 +223,13 @@ impl TestCaseBuilder<MockedTypeshed> {
 
         Program::from_settings(
             &db,
-            &ProgramSettings {
+            ProgramSettings {
                 target_version,
                 search_paths: SearchPathSettings {
                     extra_paths: vec![],
                     src_root: src.clone(),
                     custom_typeshed: Some(typeshed.clone()),
-                    site_packages: SitePackages::Known(vec![site_packages.clone()]),
+                    site_packages: vec![site_packages.clone()],
                 },
             },
         )
@@ -281,11 +279,13 @@ impl TestCaseBuilder<VendoredTypeshed> {
 
         Program::from_settings(
             &db,
-            &ProgramSettings {
+            ProgramSettings {
                 target_version,
                 search_paths: SearchPathSettings {
-                    site_packages: SitePackages::Known(vec![site_packages.clone()]),
-                    ..SearchPathSettings::new(src.clone())
+                    extra_paths: vec![],
+                    src_root: src.clone(),
+                    custom_typeshed: None,
+                    site_packages: vec![site_packages.clone()],
                 },
             },
         )

crates/red_knot_python_semantic/src/module_resolver/typeshed/mod.rs

@@ -1,6 +1,6 @@
 pub use self::vendored::vendored_typeshed_stubs;
 pub(super) use self::versions::{
-    typeshed_versions, vendored_typeshed_versions, TypeshedVersions, TypeshedVersionsParseError,
+    parse_typeshed_versions, LazyTypeshedVersions, TypeshedVersionsParseError,
     TypeshedVersionsQueryResult,
 };
 

crates/red_knot_python_semantic/src/module_resolver/typeshed/versions.rs

@@ -1,3 +1,4 @@
+use std::cell::OnceCell;
 use std::collections::BTreeMap;
 use std::fmt;
 use std::num::{NonZeroU16, NonZeroUsize};
@@ -5,12 +6,78 @@ use std::ops::{RangeFrom, RangeInclusive};
 use std::str::FromStr;
 
 use once_cell::sync::Lazy;
+use ruff_db::system::SystemPath;
 use rustc_hash::FxHashMap;
 
+use ruff_db::files::{system_path_to_file, File};
+
 use super::vendored::vendored_typeshed_stubs;
 use crate::db::Db;
 use crate::module_name::ModuleName;
-use crate::{Program, PythonVersion};
+use crate::python_version::PythonVersion;
+
+#[derive(Debug)]
+pub(crate) struct LazyTypeshedVersions<'db>(OnceCell<&'db TypeshedVersions>);
+
+impl<'db> LazyTypeshedVersions<'db> {
+    #[must_use]
+    pub(crate) fn new() -> Self {
+        Self(OnceCell::new())
+    }
+
+    /// Query whether a module exists at runtime in the stdlib on a certain Python version.
+    ///
+    /// Simply probing whether a file exists in typeshed is insufficient for this question,
+    /// as a module in the stdlib may have been added in Python 3.10, but the typeshed stub
+    /// will still be available (either in a custom typeshed dir or in our vendored copy)
+    /// even if the user specified Python 3.8 as the target version.
+    ///
+    /// For top-level modules and packages, the VERSIONS file can always provide an unambiguous answer
+    /// as to whether the module exists on the specified target version. However, VERSIONS does not
+    /// provide comprehensive information on all submodules, meaning that this method sometimes
+    /// returns [`TypeshedVersionsQueryResult::MaybeExists`].
+    /// See [`TypeshedVersionsQueryResult`] for more details.
+    #[must_use]
+    pub(crate) fn query_module(
+        &self,
+        db: &'db dyn Db,
+        module: &ModuleName,
+        stdlib_root: Option<&SystemPath>,
+        target_version: PythonVersion,
+    ) -> TypeshedVersionsQueryResult {
+        let versions = self.0.get_or_init(|| {
+            let versions_path = if let Some(system_path) = stdlib_root {
+                system_path.join("VERSIONS")
+            } else {
+                return &VENDORED_VERSIONS;
+            };
+            let Ok(versions_file) = system_path_to_file(db.upcast(), &versions_path) else {
+                todo!(
+                    "Still need to figure out how to handle VERSIONS files being deleted \
+                    from custom typeshed directories! Expected a file to exist at {versions_path}"
+                )
+            };
+            // TODO(Alex/Micha): If VERSIONS is invalid,
+            // this should invalidate not just the specific module resolution we're currently attempting,
+            // but all type inference that depends on any standard-library types.
+            // Unwrapping here is not correct...
+            parse_typeshed_versions(db, versions_file).as_ref().unwrap()
+        });
+        versions.query_module(module, target_version)
+    }
+}
+
+#[salsa::tracked(return_ref)]
+pub(crate) fn parse_typeshed_versions(
+    db: &dyn Db,
+    versions_file: File,
+) -> Result<TypeshedVersions, TypeshedVersionsParseError> {
+    // TODO: Handle IO errors
+    let file_content = versions_file
+        .read_to_string(db.upcast())
+        .unwrap_or_default();
+    file_content.parse()
+}
 
 static VENDORED_VERSIONS: Lazy<TypeshedVersions> = Lazy::new(|| {
     TypeshedVersions::from_str(
@@ -21,14 +88,6 @@ static VENDORED_VERSIONS: Lazy<TypeshedVersions> = Lazy::new(|| {
     .unwrap()
 });
 
-pub(crate) fn vendored_typeshed_versions() -> &'static TypeshedVersions {
-    &VENDORED_VERSIONS
-}
-
-pub(crate) fn typeshed_versions(db: &dyn Db) -> &TypeshedVersions {
-    Program::get(db).search_paths(db).typeshed_versions()
-}
-
 #[derive(Debug, PartialEq, Eq, Clone)]
 pub(crate) struct TypeshedVersionsParseError {
     line_number: Option<NonZeroU16>,
@@ -115,7 +174,7 @@ impl TypeshedVersions {
     }
 
     #[must_use]
-    pub(in crate::module_resolver) fn query_module(
+    fn query_module(
         &self,
         module: &ModuleName,
         target_version: PythonVersion,
@@ -145,7 +204,7 @@ impl TypeshedVersions {
     }
 }
 
-/// Possible answers [`TypeshedVersions::query_module()`] could give to the question:
+/// Possible answers [`LazyTypeshedVersions::query_module()`] could give to the question:
 /// "Does this module exist in the stdlib at runtime on a certain target version?"
 #[derive(Debug, Copy, PartialEq, Eq, Clone, Hash)]
 pub(crate) enum TypeshedVersionsQueryResult {

crates/red_knot_python_semantic/src/node_key.rs

@@ -1,4 +1,4 @@
-use ruff_python_ast::{AnyNodeRef, NodeKind};
+use ruff_python_ast::{AnyNodeRef, AstNode, NodeKind};
 use ruff_text_size::{Ranged, TextRange};
 
 /// Compact key for a node for use in a hash map.
@@ -11,7 +11,19 @@ pub(super) struct NodeKey {
 }
 
 impl NodeKey {
-    pub(super) fn from_node<'a, N>(node: N) -> Self
+    #[inline]
+    pub(super) fn from_node<'a, N>(node: &N) -> Self
+    where
+        N: AstNode,
+    {
+        NodeKey {
+            kind: node.kind(),
+            range: node.range(),
+        }
+    }
+
+    #[inline]
+    pub(super) fn from_ref<'a, N>(node: N) -> Self
     where
         N: Into<AnyNodeRef<'a>>,
     {

crates/red_knot_python_semantic/src/program.rs

@@ -3,7 +3,7 @@ use anyhow::Context;
 use salsa::Durability;
 use salsa::Setter;
 
-use ruff_db::system::{SystemPath, SystemPathBuf};
+use ruff_db::system::SystemPathBuf;
 
 use crate::module_resolver::SearchPaths;
 use crate::Db;
@@ -12,12 +12,13 @@ use crate::Db;
 pub struct Program {
     pub target_version: PythonVersion,
 
+    #[default]
     #[return_ref]
     pub(crate) search_paths: SearchPaths,
 }
 
 impl Program {
-    pub fn from_settings(db: &dyn Db, settings: &ProgramSettings) -> anyhow::Result<Self> {
+    pub fn from_settings(db: &dyn Db, settings: ProgramSettings) -> anyhow::Result<Self> {
         let ProgramSettings {
             target_version,
             search_paths,
@@ -28,15 +29,16 @@ impl Program {
         let search_paths = SearchPaths::from_settings(db, search_paths)
             .with_context(|| "Invalid search path settings")?;
 
-        Ok(Program::builder(settings.target_version, search_paths)
+        Ok(Program::builder(settings.target_version)
             .durability(Durability::HIGH)
+            .search_paths(search_paths)
             .new(db))
     }
 
     pub fn update_search_paths(
-        self,
+        &self,
         db: &mut dyn Db,
-        search_path_settings: &SearchPathSettings,
+        search_path_settings: SearchPathSettings,
     ) -> anyhow::Result<()> {
         let search_paths = SearchPaths::from_settings(db, search_path_settings)?;
 
@@ -47,20 +49,16 @@ impl Program {
 
         Ok(())
     }
-
-    pub fn custom_stdlib_search_path(self, db: &dyn Db) -> Option<&SystemPath> {
-        self.search_paths(db).custom_stdlib()
-    }
 }
 
-#[derive(Clone, Debug, Eq, PartialEq)]
+#[derive(Debug, Eq, PartialEq)]
 pub struct ProgramSettings {
     pub target_version: PythonVersion,
     pub search_paths: SearchPathSettings,
 }
 
 /// Configures the search paths for module resolution.
-#[derive(Eq, PartialEq, Debug, Clone)]
+#[derive(Eq, PartialEq, Debug, Clone, Default)]
 pub struct SearchPathSettings {
     /// List of user-provided paths that should take first priority in the module resolution.
     /// Examples in other type checkers are mypy's MYPYPATH environment variable,
@@ -76,25 +74,5 @@ pub struct SearchPathSettings {
     pub custom_typeshed: Option<SystemPathBuf>,
 
     /// The path to the user's `site-packages` directory, where third-party packages from ``PyPI`` are installed.
-    pub site_packages: SitePackages,
-}
-
-impl SearchPathSettings {
-    pub fn new(src_root: SystemPathBuf) -> Self {
-        Self {
-            src_root,
-            extra_paths: vec![],
-            custom_typeshed: None,
-            site_packages: SitePackages::Known(vec![]),
-        }
-    }
-}
-
-#[derive(Debug, Clone, Eq, PartialEq)]
-pub enum SitePackages {
-    Derived {
-        venv_path: SystemPathBuf,
-    },
-    /// Resolved site packages paths
-    Known(Vec<SystemPathBuf>),
+    pub site_packages: Vec<SystemPathBuf>,
 }

crates/red_knot_python_semantic/src/semantic_index.rs

@@ -790,56 +790,6 @@ def f(a: str, /, b: str, c: int = 1, *args, d: int = 2, **kwargs):
         assert_eq!(names(&inner_comprehension_symbol_table), vec!["x"]);
     }
 
-    #[test]
-    fn with_item_definition() {
-        let TestCase { db, file } = test_case(
-            "
-with item1 as x, item2 as y:
-    pass
-",
-        );
-
-        let index = semantic_index(&db, file);
-        let global_table = index.symbol_table(FileScopeId::global());
-
-        assert_eq!(names(&global_table), vec!["item1", "x", "item2", "y"]);
-
-        let use_def = index.use_def_map(FileScopeId::global());
-        for name in ["x", "y"] {
-            let Some(definition) = use_def.first_public_definition(
-                global_table.symbol_id_by_name(name).expect("symbol exists"),
-            ) else {
-                panic!("Expected with item definition for {name}");
-            };
-            assert!(matches!(definition.node(&db), DefinitionKind::WithItem(_)));
-        }
-    }
-
-    #[test]
-    fn with_item_unpacked_definition() {
-        let TestCase { db, file } = test_case(
-            "
-with context() as (x, y):
-    pass
-",
-        );
-
-        let index = semantic_index(&db, file);
-        let global_table = index.symbol_table(FileScopeId::global());
-
-        assert_eq!(names(&global_table), vec!["context", "x", "y"]);
-
-        let use_def = index.use_def_map(FileScopeId::global());
-        for name in ["x", "y"] {
-            let Some(definition) = use_def.first_public_definition(
-                global_table.symbol_id_by_name(name).expect("symbol exists"),
-            ) else {
-                panic!("Expected with item definition for {name}");
-            };
-            assert!(matches!(definition.node(&db), DefinitionKind::WithItem(_)));
-        }
-    }
-
     #[test]
     fn dupes() {
         let TestCase { db, file } = test_case(

crates/red_knot_python_semantic/src/semantic_index/ast_ids.rs

@@ -197,12 +197,14 @@ pub(crate) mod node_key {
     pub(crate) struct ExpressionNodeKey(NodeKey);
 
     impl From<ast::ExpressionRef<'_>> for ExpressionNodeKey {
+        #[inline]
         fn from(value: ast::ExpressionRef<'_>) -> Self {
-            Self(NodeKey::from_node(value))
+            Self(NodeKey::from_ref(value))
         }
     }
 
     impl From<&ast::Expr> for ExpressionNodeKey {
+        #[inline]
         fn from(value: &ast::Expr) -> Self {
             Self(NodeKey::from_node(value))
         }

crates/red_knot_python_semantic/src/semantic_index/builder.rs

@@ -26,8 +26,6 @@ use crate::semantic_index::use_def::{FlowSnapshot, UseDefMapBuilder};
 use crate::semantic_index::SemanticIndex;
 use crate::Db;
 
-use super::definition::WithItemDefinitionNodeRef;
-
 pub(super) struct SemanticIndexBuilder<'db> {
     // Builder state
     db: &'db dyn Db,
@@ -563,18 +561,6 @@ where
                     self.flow_merge(break_state);
                 }
             }
-            ast::Stmt::With(ast::StmtWith { items, body, .. }) => {
-                for item in items {
-                    self.visit_expr(&item.context_expr);
-                    if let Some(optional_vars) = item.optional_vars.as_deref() {
-                        self.add_standalone_expression(&item.context_expr);
-                        self.current_assignment = Some(item.into());
-                        self.visit_expr(optional_vars);
-                        self.current_assignment = None;
-                    }
-                }
-                self.visit_body(body);
-            }
             ast::Stmt::Break(_) => {
                 self.loop_break_states.push(self.flow_snapshot());
             }
@@ -636,15 +622,6 @@ where
                                 ComprehensionDefinitionNodeRef { node, first },
                             );
                         }
-                        Some(CurrentAssignment::WithItem(with_item)) => {
-                            self.add_definition(
-                                symbol,
-                                WithItemDefinitionNodeRef {
-                                    node: with_item,
-                                    target: name_node,
-                                },
-                            );
-                        }
                         None => {}
                     }
                 }
@@ -801,7 +778,6 @@ enum CurrentAssignment<'a> {
         node: &'a ast::Comprehension,
         first: bool,
     },
-    WithItem(&'a ast::WithItem),
 }
 
 impl<'a> From<&'a ast::StmtAssign> for CurrentAssignment<'a> {
@@ -827,9 +803,3 @@ impl<'a> From<&'a ast::ExprNamed> for CurrentAssignment<'a> {
         Self::Named(value)
     }
 }
-
-impl<'a> From<&'a ast::WithItem> for CurrentAssignment<'a> {
-    fn from(value: &'a ast::WithItem) -> Self {
-        Self::WithItem(value)
-    }
-}

crates/red_knot_python_semantic/src/semantic_index/definition.rs

@@ -47,7 +47,6 @@ pub(crate) enum DefinitionNodeRef<'a> {
     AugmentedAssignment(&'a ast::StmtAugAssign),
     Comprehension(ComprehensionDefinitionNodeRef<'a>),
     Parameter(ast::AnyParameterRef<'a>),
-    WithItem(WithItemDefinitionNodeRef<'a>),
 }
 
 impl<'a> From<&'a ast::StmtFunctionDef> for DefinitionNodeRef<'a> {
@@ -98,12 +97,6 @@ impl<'a> From<AssignmentDefinitionNodeRef<'a>> for DefinitionNodeRef<'a> {
     }
 }
 
-impl<'a> From<WithItemDefinitionNodeRef<'a>> for DefinitionNodeRef<'a> {
-    fn from(node_ref: WithItemDefinitionNodeRef<'a>) -> Self {
-        Self::WithItem(node_ref)
-    }
-}
-
 impl<'a> From<ComprehensionDefinitionNodeRef<'a>> for DefinitionNodeRef<'a> {
     fn from(node: ComprehensionDefinitionNodeRef<'a>) -> Self {
         Self::Comprehension(node)
@@ -128,12 +121,6 @@ pub(crate) struct AssignmentDefinitionNodeRef<'a> {
     pub(crate) target: &'a ast::ExprName,
 }
 
-#[derive(Copy, Clone, Debug)]
-pub(crate) struct WithItemDefinitionNodeRef<'a> {
-    pub(crate) node: &'a ast::WithItem,
-    pub(crate) target: &'a ast::ExprName,
-}
-
 #[derive(Copy, Clone, Debug)]
 pub(crate) struct ComprehensionDefinitionNodeRef<'a> {
     pub(crate) node: &'a ast::Comprehension,
@@ -188,12 +175,6 @@ impl DefinitionNodeRef<'_> {
                     DefinitionKind::ParameterWithDefault(AstNodeRef::new(parsed, parameter))
                 }
             },
-            DefinitionNodeRef::WithItem(WithItemDefinitionNodeRef { node, target }) => {
-                DefinitionKind::WithItem(WithItemDefinitionKind {
-                    node: AstNodeRef::new(parsed.clone(), node),
-                    target: AstNodeRef::new(parsed, target),
-                })
-            }
         }
     }
 
@@ -217,7 +198,6 @@ impl DefinitionNodeRef<'_> {
                 ast::AnyParameterRef::Variadic(parameter) => parameter.into(),
                 ast::AnyParameterRef::NonVariadic(parameter) => parameter.into(),
             },
-            Self::WithItem(WithItemDefinitionNodeRef { node: _, target }) => target.into(),
         }
     }
 }
@@ -235,7 +215,6 @@ pub enum DefinitionKind {
     Comprehension(ComprehensionDefinitionKind),
     Parameter(AstNodeRef<ast::Parameter>),
     ParameterWithDefault(AstNodeRef<ast::ParameterWithDefault>),
-    WithItem(WithItemDefinitionKind),
 }
 
 #[derive(Clone, Debug)]
@@ -271,6 +250,7 @@ impl ImportFromDefinitionKind {
 }
 
 #[derive(Clone, Debug)]
+#[allow(dead_code)]
 pub struct AssignmentDefinitionKind {
     assignment: AstNodeRef<ast::StmtAssign>,
     target: AstNodeRef<ast::ExprName>,
@@ -286,22 +266,6 @@ impl AssignmentDefinitionKind {
     }
 }
 
-#[derive(Clone, Debug)]
-pub struct WithItemDefinitionKind {
-    node: AstNodeRef<ast::WithItem>,
-    target: AstNodeRef<ast::ExprName>,
-}
-
-impl WithItemDefinitionKind {
-    pub(crate) fn node(&self) -> &ast::WithItem {
-        self.node.node()
-    }
-
-    pub(crate) fn target(&self) -> &ast::ExprName {
-        self.target.node()
-    }
-}
-
 #[derive(Copy, Clone, Eq, PartialEq, Hash, Debug)]
 pub(crate) struct DefinitionNodeKey(NodeKey);
 

crates/red_knot_python_semantic/src/semantic_model.rs

@@ -184,9 +184,14 @@ mod tests {
 
         Program::from_settings(
             &db,
-            &ProgramSettings {
+            ProgramSettings {
                 target_version: PythonVersion::default(),
-                search_paths: SearchPathSettings::new(SystemPathBuf::from("/src")),
+                search_paths: SearchPathSettings {
+                    extra_paths: vec![],
+                    src_root: SystemPathBuf::from("/src"),
+                    site_packages: vec![],
+                    custom_typeshed: None,
+                },
             },
         )?;
 

crates/red_knot_python_semantic/src/types.rs

@@ -392,9 +392,14 @@ mod tests {
 
         Program::from_settings(
             &db,
-            &ProgramSettings {
+            ProgramSettings {
                 target_version: PythonVersion::default(),
-                search_paths: SearchPathSettings::new(SystemPathBuf::from("/src")),
+                search_paths: SearchPathSettings {
+                    extra_paths: Vec::new(),
+                    src_root: SystemPathBuf::from("/src"),
+                    site_packages: vec![],
+                    custom_typeshed: None,
+                },
             },
         )
         .expect("Valid search path settings");

crates/red_knot_python_semantic/src/types/infer.rs

@@ -333,9 +333,6 @@ impl<'db> TypeInferenceBuilder<'db> {
             DefinitionKind::ParameterWithDefault(parameter_with_default) => {
                 self.infer_parameter_with_default_definition(parameter_with_default, definition);
             }
-            DefinitionKind::WithItem(with_item) => {
-                self.infer_with_item_definition(with_item.target(), with_item.node(), definition);
-            }
         }
     }
 
@@ -621,42 +618,13 @@ impl<'db> TypeInferenceBuilder<'db> {
         } = with_statement;
 
         for item in items {
-            match item.optional_vars.as_deref() {
-                Some(ast::Expr::Name(name)) => {
-                    self.infer_definition(name);
-                }
-                _ => {
-                    // TODO infer definitions in unpacking assignment
-                    self.infer_expression(&item.context_expr);
-                }
-            }
+            self.infer_expression(&item.context_expr);
+            self.infer_optional_expression(item.optional_vars.as_deref());
         }
 
         self.infer_body(body);
     }
 
-    fn infer_with_item_definition(
-        &mut self,
-        target: &ast::ExprName,
-        with_item: &ast::WithItem,
-        definition: Definition<'db>,
-    ) {
-        let expression = self.index.expression(&with_item.context_expr);
-        let result = infer_expression_types(self.db, expression);
-        self.extend(result);
-
-        // TODO(dhruvmanila): The correct type inference here is the return type of the __enter__
-        // method of the context manager.
-        let context_expr_ty = self
-            .types
-            .expression_ty(with_item.context_expr.scoped_ast_id(self.db, self.scope));
-
-        self.types
-            .expressions
-            .insert(target.scoped_ast_id(self.db, self.scope), context_expr_ty);
-        self.types.definitions.insert(definition, context_expr_ty);
-    }
-
     fn infer_match_statement(&mut self, match_statement: &ast::StmtMatch) {
         let ast::StmtMatch {
             range: _,
@@ -1898,9 +1866,14 @@ mod tests {
 
         Program::from_settings(
             &db,
-            &ProgramSettings {
+            ProgramSettings {
                 target_version: PythonVersion::default(),
-                search_paths: SearchPathSettings::new(src_root),
+                search_paths: SearchPathSettings {
+                    extra_paths: Vec::new(),
+                    src_root,
+                    site_packages: vec![],
+                    custom_typeshed: None,
+                },
             },
         )
         .expect("Valid search path settings");
@@ -1920,11 +1893,13 @@ mod tests {
 
         Program::from_settings(
             &db,
-            &ProgramSettings {
+            ProgramSettings {
                 target_version: PythonVersion::default(),
                 search_paths: SearchPathSettings {
+                    extra_paths: Vec::new(),
+                    src_root,
+                    site_packages: vec![],
                     custom_typeshed: Some(SystemPathBuf::from(typeshed)),
-                    ..SearchPathSettings::new(src_root)
                 },
             },
         )

crates/red_knot_server/Cargo.toml

@@ -11,6 +11,7 @@ repository = { workspace = true }
 license = { workspace = true }
 
 [dependencies]
+red_knot_python_semantic = { workspace = true }
 red_knot_workspace = { workspace = true }
 ruff_db = { workspace = true }
 ruff_notebook = { workspace = true }

crates/red_knot_server/src/server.rs

@@ -3,10 +3,11 @@
 use std::num::NonZeroUsize;
 use std::panic::PanicInfo;
 
-use lsp_server::Message;
+use lsp_server as lsp;
+use lsp_types as types;
 use lsp_types::{
-    ClientCapabilities, DiagnosticOptions, DiagnosticServerCapabilities, MessageType,
-    ServerCapabilities, TextDocumentSyncCapability, TextDocumentSyncOptions, Url,
+    ClientCapabilities, DiagnosticOptions, NotebookCellSelector, NotebookDocumentSyncOptions,
+    NotebookSelector, TextDocumentSyncCapability, TextDocumentSyncOptions,
 };
 
 use self::connection::{Connection, ConnectionInitializer};
@@ -73,7 +74,7 @@ impl Server {
             init_params.client_info.as_ref(),
         );
 
-        let mut workspace_for_url = |url: Url| {
+        let mut workspace_for_url = |url: lsp_types::Url| {
             let Some(workspace_settings) = workspace_settings.as_mut() else {
                 return (url, ClientSettings::default());
             };
@@ -92,7 +93,7 @@ impl Server {
             }).collect())
             .or_else(|| {
                 tracing::warn!("No workspace(s) were provided during initialization. Using the current working directory as a default workspace...");
-                let uri = Url::from_file_path(std::env::current_dir().ok()?).ok()?;
+                let uri = types::Url::from_file_path(std::env::current_dir().ok()?).ok()?;
                 Some(vec![workspace_for_url(uri)])
             })
             .ok_or_else(|| {
@@ -148,7 +149,7 @@ impl Server {
             try_show_message(
                 "The Ruff language server exited with a panic. See the logs for more details."
                     .to_string(),
-                MessageType::ERROR,
+                lsp_types::MessageType::ERROR,
             )
             .ok();
         }));
@@ -181,9 +182,9 @@ impl Server {
                 break;
             }
             let task = match msg {
-                Message::Request(req) => api::request(req),
-                Message::Notification(notification) => api::notification(notification),
-                Message::Response(response) => scheduler.response(response),
+                lsp::Message::Request(req) => api::request(req),
+                lsp::Message::Notification(notification) => api::notification(notification),
+                lsp::Message::Response(response) => scheduler.response(response),
             };
             scheduler.dispatch(task);
         }
@@ -205,12 +206,24 @@ impl Server {
             .unwrap_or_default()
     }
 
-    fn server_capabilities(position_encoding: PositionEncoding) -> ServerCapabilities {
-        ServerCapabilities {
+    fn server_capabilities(position_encoding: PositionEncoding) -> types::ServerCapabilities {
+        types::ServerCapabilities {
             position_encoding: Some(position_encoding.into()),
-            diagnostic_provider: Some(DiagnosticServerCapabilities::Options(DiagnosticOptions {
-                identifier: Some(crate::DIAGNOSTIC_NAME.into()),
-                ..Default::default()
+            diagnostic_provider: Some(types::DiagnosticServerCapabilities::Options(
+                DiagnosticOptions {
+                    identifier: Some(crate::DIAGNOSTIC_NAME.into()),
+                    ..Default::default()
+                },
+            )),
+            notebook_document_sync: Some(types::OneOf::Left(NotebookDocumentSyncOptions {
+                save: Some(false),
+                notebook_selector: [NotebookSelector::ByCells {
+                    notebook: None,
+                    cells: vec![NotebookCellSelector {
+                        language: "python".to_string(),
+                    }],
+                }]
+                .to_vec(),
             })),
             text_document_sync: Some(TextDocumentSyncCapability::Options(
                 TextDocumentSyncOptions {

crates/red_knot_server/src/session.rs

@@ -8,6 +8,7 @@ use std::sync::Arc;
 use anyhow::anyhow;
 use lsp_types::{ClientCapabilities, Url};
 
+use red_knot_python_semantic::{ProgramSettings, PythonVersion, SearchPathSettings};
 use red_knot_workspace::db::RootDatabase;
 use red_knot_workspace::workspace::WorkspaceMetadata;
 use ruff_db::files::{system_path_to_file, File};
@@ -66,10 +67,19 @@ impl Session {
                 .ok_or_else(|| anyhow!("Workspace path is not a valid UTF-8 path: {:?}", path))?;
             let system = LSPSystem::new(index.clone());
 
+            let metadata = WorkspaceMetadata::from_path(system_path, &system)?;
             // TODO(dhruvmanila): Get the values from the client settings
-            let metadata = WorkspaceMetadata::from_path(system_path, &system, None)?;
+            let program_settings = ProgramSettings {
+                target_version: PythonVersion::default(),
+                search_paths: SearchPathSettings {
+                    extra_paths: vec![],
+                    src_root: system_path.to_path_buf(),
+                    site_packages: vec![],
+                    custom_typeshed: None,
+                },
+            };
             // TODO(micha): Handle the case where the program settings are incorrect more gracefully.
-            workspaces.insert(path, RootDatabase::new(metadata, system)?);
+            workspaces.insert(path, RootDatabase::new(metadata, program_settings, system)?);
         }
 
         Ok(Self {

crates/red_knot_wasm/src/lib.rs

@@ -3,8 +3,8 @@ use std::any::Any;
 use js_sys::Error;
 use wasm_bindgen::prelude::*;
 
+use red_knot_python_semantic::{ProgramSettings, SearchPathSettings};
 use red_knot_workspace::db::RootDatabase;
-use red_knot_workspace::workspace::settings::Configuration;
 use red_knot_workspace::workspace::WorkspaceMetadata;
 use ruff_db::files::{system_path_to_file, File};
 use ruff_db::system::walk_directory::WalkDirectoryBuilder;
@@ -41,17 +41,16 @@ impl Workspace {
     #[wasm_bindgen(constructor)]
     pub fn new(root: &str, settings: &Settings) -> Result<Workspace, Error> {
         let system = WasmSystem::new(SystemPath::new(root));
-        let workspace = WorkspaceMetadata::from_path(
-            SystemPath::new(root),
-            &system,
-            Some(Configuration {
-                target_version: Some(settings.target_version.into()),
-                ..Configuration::default()
-            }),
-        )
-        .map_err(into_error)?;
+        let workspace =
+            WorkspaceMetadata::from_path(SystemPath::new(root), &system).map_err(into_error)?;
 
-        let db = RootDatabase::new(workspace, system.clone()).map_err(into_error)?;
+        let program_settings = ProgramSettings {
+            target_version: settings.target_version.into(),
+            search_paths: SearchPathSettings::default(),
+        };
+
+        let db =
+            RootDatabase::new(workspace, program_settings, system.clone()).map_err(into_error)?;
 
         Ok(Self { db, system })
     }

crates/red_knot_workspace/Cargo.toml

@@ -24,6 +24,7 @@ crossbeam = { workspace = true }
 notify = { workspace = true }
 rustc-hash = { workspace = true }
 salsa = { workspace = true }
+thiserror = { workspace = true }
 tracing = { workspace = true }
 
 [dev-dependencies]

crates/red_knot_workspace/src/db.rs

@@ -1,14 +1,15 @@
 use std::panic::RefUnwindSafe;
 use std::sync::Arc;
 
-use salsa::plumbing::ZalsaDatabase;
-use salsa::{Cancelled, Event};
-
-use red_knot_python_semantic::{vendored_typeshed_stubs, Db as SemanticDb, Program};
+use red_knot_python_semantic::{
+    vendored_typeshed_stubs, Db as SemanticDb, Program, ProgramSettings,
+};
 use ruff_db::files::{File, Files};
 use ruff_db::system::System;
 use ruff_db::vendored::VendoredFileSystem;
 use ruff_db::{Db as SourceDb, Upcast};
+use salsa::plumbing::ZalsaDatabase;
+use salsa::{Cancelled, Event};
 
 use crate::workspace::{check_file, Workspace, WorkspaceMetadata};
 
@@ -26,7 +27,11 @@ pub struct RootDatabase {
 }
 
 impl RootDatabase {
-    pub fn new<S>(workspace: WorkspaceMetadata, system: S) -> anyhow::Result<Self>
+    pub fn new<S>(
+        workspace: WorkspaceMetadata,
+        settings: ProgramSettings,
+        system: S,
+    ) -> anyhow::Result<Self>
     where
         S: System + 'static + Send + Sync + RefUnwindSafe,
     {
@@ -37,11 +42,11 @@ impl RootDatabase {
             system: Arc::new(system),
         };
 
+        let workspace = Workspace::from_metadata(&db, workspace);
         // Initialize the `Program` singleton
-        Program::from_settings(&db, workspace.settings().program())?;
-
-        db.workspace = Some(Workspace::from_metadata(&db, workspace));
+        Program::from_settings(&db, settings)?;
 
+        db.workspace = Some(workspace);
         Ok(db)
     }
 
@@ -155,9 +160,8 @@ impl Db for RootDatabase {}
 
 #[cfg(test)]
 pub(crate) mod tests {
-    use std::sync::Arc;
-
     use salsa::Event;
+    use std::sync::Arc;
 
     use red_knot_python_semantic::{vendored_typeshed_stubs, Db as SemanticDb};
     use ruff_db::files::Files;

crates/red_knot_workspace/src/db/changes.rs

@@ -1,33 +1,22 @@
-use red_knot_python_semantic::Program;
+use rustc_hash::FxHashSet;
+
 use ruff_db::files::{system_path_to_file, File, Files};
 use ruff_db::system::walk_directory::WalkState;
 use ruff_db::system::SystemPath;
 use ruff_db::Db;
-use rustc_hash::FxHashSet;
 
 use crate::db::RootDatabase;
 use crate::watch;
 use crate::watch::{CreatedKind, DeletedKind};
-use crate::workspace::settings::Configuration;
 use crate::workspace::WorkspaceMetadata;
 
 impl RootDatabase {
-    #[tracing::instrument(level = "debug", skip(self, changes, base_configuration))]
-    pub fn apply_changes(
-        &mut self,
-        changes: Vec<watch::ChangeEvent>,
-        base_configuration: Option<&Configuration>,
-    ) {
+    #[tracing::instrument(level = "debug", skip(self, changes))]
+    pub fn apply_changes(&mut self, changes: Vec<watch::ChangeEvent>) {
         let workspace = self.workspace();
         let workspace_path = workspace.root(self).to_path_buf();
-        let program = Program::get(self);
-        let custom_stdlib_versions_path = program
-            .custom_stdlib_search_path(self)
-            .map(|path| path.join("VERSIONS"));
 
         let mut workspace_change = false;
-        // Changes to a custom stdlib path's VERSIONS
-        let mut custom_stdlib_change = false;
         // Packages that need reloading
         let mut changed_packages = FxHashSet::default();
         // Paths that were added
@@ -65,10 +54,6 @@ impl RootDatabase {
 
                     continue;
                 }
-
-                if Some(path) == custom_stdlib_versions_path.as_deref() {
-                    custom_stdlib_change = true;
-                }
             }
 
             match change {
@@ -115,13 +100,7 @@ impl RootDatabase {
                     } else {
                         sync_recursively(self, &path);
 
-                        if custom_stdlib_versions_path
-                            .as_ref()
-                            .is_some_and(|versions_path| versions_path.starts_with(&path))
-                        {
-                            custom_stdlib_change = true;
-                        }
-
+                        // TODO: Remove after converting `package.files()` to a salsa query.
                         if let Some(package) = workspace.package(self, &path) {
                             changed_packages.insert(package);
                         } else {
@@ -139,11 +118,7 @@ impl RootDatabase {
         }
 
         if workspace_change {
-            match WorkspaceMetadata::from_path(
-                &workspace_path,
-                self.system(),
-                base_configuration.cloned(),
-            ) {
+            match WorkspaceMetadata::from_path(&workspace_path, self.system()) {
                 Ok(metadata) => {
                     tracing::debug!("Reloading workspace after structural change.");
                     // TODO: Handle changes in the program settings.
@@ -155,11 +130,6 @@ impl RootDatabase {
             }
 
             return;
-        } else if custom_stdlib_change {
-            let search_paths = workspace.search_path_settings(self).clone();
-            if let Err(error) = program.update_search_paths(self, &search_paths) {
-                tracing::error!("Failed to set the new search paths: {error}");
-            }
         }
 
         let mut added_paths = added_paths.into_iter().filter(|path| {

crates/red_knot_workspace/src/lib.rs

@@ -1,4 +1,5 @@
 pub mod db;
 pub mod lint;
+pub mod site_packages;
 pub mod watch;
 pub mod workspace;

crates/red_knot_workspace/src/lint.rs

@@ -286,9 +286,14 @@ mod tests {
 
         Program::from_settings(
             &db,
-            &ProgramSettings {
+            ProgramSettings {
                 target_version: PythonVersion::default(),
-                search_paths: SearchPathSettings::new(src_root),
+                search_paths: SearchPathSettings {
+                    extra_paths: Vec::new(),
+                    src_root,
+                    site_packages: vec![],
+                    custom_typeshed: None,
+                },
             },
         )
         .expect("Valid program settings");

crates/red_knot_workspace/src/site_packages.rs

@@ -13,10 +13,9 @@ use std::io;
 use std::num::NonZeroUsize;
 use std::ops::Deref;
 
+use red_knot_python_semantic::PythonVersion;
 use ruff_db::system::{System, SystemPath, SystemPathBuf};
 
-use crate::PythonVersion;
-
 type SitePackagesDiscoveryResult<T> = Result<T, SitePackagesDiscoveryError>;
 
 /// Abstraction for a Python virtual environment.
@@ -25,7 +24,7 @@ type SitePackagesDiscoveryResult<T> = Result<T, SitePackagesDiscoveryError>;
 /// The format of this file is not defined anywhere, and exactly which keys are present
 /// depends on the tool that was used to create the virtual environment.
 #[derive(Debug)]
-pub(crate) struct VirtualEnvironment {
+pub struct VirtualEnvironment {
     venv_path: SysPrefixPath,
     base_executable_home_path: PythonHomePath,
     include_system_site_packages: bool,
@@ -42,7 +41,7 @@ pub(crate) struct VirtualEnvironment {
 }
 
 impl VirtualEnvironment {
-    pub(crate) fn new(
+    pub fn new(
         path: impl AsRef<SystemPath>,
         system: &dyn System,
     ) -> SitePackagesDiscoveryResult<Self> {
@@ -158,7 +157,7 @@ impl VirtualEnvironment {
     /// Return a list of `site-packages` directories that are available from this virtual environment
     ///
     /// See the documentation for `site_packages_dir_from_sys_prefix` for more details.
-    pub(crate) fn site_packages_directories(
+    pub fn site_packages_directories(
         &self,
         system: &dyn System,
     ) -> SitePackagesDiscoveryResult<Vec<SystemPathBuf>> {
@@ -205,7 +204,7 @@ System site-packages will not be used for module resolution.",
 }
 
 #[derive(Debug, thiserror::Error)]
-pub(crate) enum SitePackagesDiscoveryError {
+pub enum SitePackagesDiscoveryError {
     #[error("Invalid --venv-path argument: {0} could not be canonicalized")]
     VenvDirCanonicalizationError(SystemPathBuf, #[source] io::Error),
     #[error("Invalid --venv-path argument: {0} does not point to a directory on disk")]
@@ -222,7 +221,7 @@ pub(crate) enum SitePackagesDiscoveryError {
 
 /// The various ways in which parsing a `pyvenv.cfg` file could fail
 #[derive(Debug)]
-pub(crate) enum PyvenvCfgParseErrorKind {
+pub enum PyvenvCfgParseErrorKind {
     TooManyEquals { line_number: NonZeroUsize },
     MalformedKeyValuePair { line_number: NonZeroUsize },
     NoHomeKey,
@@ -371,7 +370,7 @@ fn site_packages_directory_from_sys_prefix(
 ///
 /// [`sys.prefix`]: https://docs.python.org/3/library/sys.html#sys.prefix
 #[derive(Debug, PartialEq, Eq, Clone)]
-pub(crate) struct SysPrefixPath(SystemPathBuf);
+pub struct SysPrefixPath(SystemPathBuf);
 
 impl SysPrefixPath {
     fn new(

crates/red_knot_workspace/src/workspace.rs

@@ -5,7 +5,6 @@ use salsa::{Durability, Setter as _};
 
 pub use metadata::{PackageMetadata, WorkspaceMetadata};
 use red_knot_python_semantic::types::check_types;
-use red_knot_python_semantic::SearchPathSettings;
 use ruff_db::source::{line_index, source_text, SourceDiagnostic};
 use ruff_db::{
     files::{system_path_to_file, File},
@@ -22,7 +21,6 @@ use crate::{
 
 mod files;
 mod metadata;
-pub mod settings;
 
 /// The project workspace as a Salsa ingredient.
 ///
@@ -83,10 +81,6 @@ pub struct Workspace {
     /// The (first-party) packages in this workspace.
     #[return_ref]
     package_tree: BTreeMap<SystemPathBuf, Package>,
-
-    /// The unresolved search path configuration.
-    #[return_ref]
-    pub search_path_settings: SearchPathSettings,
 }
 
 /// A first-party package in a workspace.
@@ -115,14 +109,10 @@ impl Workspace {
             packages.insert(package.root.clone(), Package::from_metadata(db, package));
         }
 
-        Workspace::builder(
-            metadata.root,
-            packages,
-            metadata.settings.program.search_paths,
-        )
-        .durability(Durability::MEDIUM)
-        .open_fileset_durability(Durability::LOW)
-        .new(db)
+        Workspace::builder(metadata.root, packages)
+            .durability(Durability::MEDIUM)
+            .open_fileset_durability(Durability::LOW)
+            .new(db)
     }
 
     pub fn root(self, db: &dyn Db) -> &SystemPath {
@@ -153,11 +143,6 @@ impl Workspace {
             new_packages.insert(path, package);
         }
 
-        if &metadata.settings.program.search_paths != self.search_path_settings(db) {
-            self.set_search_path_settings(db)
-                .to(metadata.settings.program.search_paths);
-        }
-
         self.set_package_tree(db).to(new_packages);
     }
 
@@ -346,7 +331,11 @@ impl Package {
                     tracing::debug_span!("index_package_files", package = %self.name(db)).entered();
 
                 let files = discover_package_files(db, self.root(db));
-                tracing::info!("Found {} files in package '{}'", files.len(), self.name(db));
+                tracing::info!(
+                    "Indexed {} files for package '{}'",
+                    files.len(),
+                    self.name(db)
+                );
                 vacant.set(files)
             }
             Index::Indexed(indexed) => indexed,

crates/red_knot_workspace/src/workspace/metadata.rs

@@ -1,4 +1,3 @@
-use crate::workspace::settings::{Configuration, WorkspaceSettings};
 use ruff_db::system::{System, SystemPath, SystemPathBuf};
 use ruff_python_ast::name::Name;
 
@@ -8,8 +7,6 @@ pub struct WorkspaceMetadata {
 
     /// The (first-party) packages in this workspace.
     pub(super) packages: Vec<PackageMetadata>,
-
-    pub(super) settings: WorkspaceSettings,
 }
 
 /// A first-party package in a workspace.
@@ -24,11 +21,7 @@ pub struct PackageMetadata {
 
 impl WorkspaceMetadata {
     /// Discovers the closest workspace at `path` and returns its metadata.
-    pub fn from_path(
-        path: &SystemPath,
-        system: &dyn System,
-        base_configuration: Option<Configuration>,
-    ) -> anyhow::Result<WorkspaceMetadata> {
+    pub fn from_path(path: &SystemPath, system: &dyn System) -> anyhow::Result<WorkspaceMetadata> {
         assert!(
             system.is_directory(path),
             "Workspace root path must be a directory"
@@ -45,20 +38,9 @@ impl WorkspaceMetadata {
             root: root.clone(),
         };
 
-        // TODO: Load the configuration from disk.
-        let mut configuration = Configuration::default();
-
-        if let Some(base_configuration) = base_configuration {
-            configuration.extend(base_configuration);
-        }
-
-        // TODO: Respect the package configurations when resolving settings (e.g. for the target version).
-        let settings = configuration.into_workspace_settings(&root);
-
         let workspace = WorkspaceMetadata {
             root,
             packages: vec![package],
-            settings,
         };
 
         Ok(workspace)
@@ -71,10 +53,6 @@ impl WorkspaceMetadata {
     pub fn packages(&self) -> &[PackageMetadata] {
         &self.packages
     }
-
-    pub fn settings(&self) -> &WorkspaceSettings {
-        &self.settings
-    }
 }
 
 impl PackageMetadata {

crates/red_knot_workspace/src/workspace/settings.rs

@@ -1,89 +0,0 @@
-use red_knot_python_semantic::{ProgramSettings, PythonVersion, SearchPathSettings, SitePackages};
-use ruff_db::system::{SystemPath, SystemPathBuf};
-
-/// The resolved configurations.
-///
-/// The main difference to [`Configuration`] is that default values are filled in.
-#[derive(Debug, Clone)]
-pub struct WorkspaceSettings {
-    pub(super) program: ProgramSettings,
-}
-
-impl WorkspaceSettings {
-    pub fn program(&self) -> &ProgramSettings {
-        &self.program
-    }
-}
-
-/// The configuration for the workspace or a package.
-#[derive(Debug, Default, Clone)]
-pub struct Configuration {
-    pub target_version: Option<PythonVersion>,
-    pub search_paths: SearchPathConfiguration,
-}
-
-impl Configuration {
-    /// Extends this configuration by using the values from `with` for all values that are absent in `self`.
-    pub fn extend(&mut self, with: Configuration) {
-        self.target_version = self.target_version.or(with.target_version);
-        self.search_paths.extend(with.search_paths);
-    }
-
-    pub fn into_workspace_settings(self, workspace_root: &SystemPath) -> WorkspaceSettings {
-        WorkspaceSettings {
-            program: ProgramSettings {
-                target_version: self.target_version.unwrap_or_default(),
-                search_paths: self.search_paths.into_settings(workspace_root),
-            },
-        }
-    }
-}
-
-#[derive(Debug, Default, Clone, Eq, PartialEq)]
-pub struct SearchPathConfiguration {
-    /// List of user-provided paths that should take first priority in the module resolution.
-    /// Examples in other type checkers are mypy's MYPYPATH environment variable,
-    /// or pyright's stubPath configuration setting.
-    pub extra_paths: Option<Vec<SystemPathBuf>>,
-
-    /// The root of the workspace, used for finding first-party modules.
-    pub src_root: Option<SystemPathBuf>,
-
-    /// Optional path to a "custom typeshed" directory on disk for us to use for standard-library types.
-    /// If this is not provided, we will fallback to our vendored typeshed stubs for the stdlib,
-    /// bundled as a zip file in the binary
-    pub custom_typeshed: Option<SystemPathBuf>,
-
-    /// The path to the user's `site-packages` directory, where third-party packages from ``PyPI`` are installed.
-    pub site_packages: Option<SitePackages>,
-}
-
-impl SearchPathConfiguration {
-    pub fn into_settings(self, workspace_root: &SystemPath) -> SearchPathSettings {
-        let site_packages = self.site_packages.unwrap_or(SitePackages::Known(vec![]));
-
-        SearchPathSettings {
-            extra_paths: self.extra_paths.unwrap_or_default(),
-            src_root: self
-                .src_root
-                .unwrap_or_else(|| workspace_root.to_path_buf()),
-            custom_typeshed: self.custom_typeshed,
-            site_packages,
-        }
-    }
-
-    pub fn extend(&mut self, with: SearchPathConfiguration) {
-        if let Some(extra_paths) = with.extra_paths {
-            self.extra_paths.get_or_insert(extra_paths);
-        }
-        if let Some(src_root) = with.src_root {
-            self.src_root.get_or_insert(src_root);
-        }
-        if let Some(custom_typeshed) = with.custom_typeshed {
-            self.custom_typeshed.get_or_insert(custom_typeshed);
-        }
-        if let Some(site_packages) = with.site_packages {
-            self.site_packages.get_or_insert(site_packages);
-        }
-    }
-}

crates/red_knot_workspace/tests/check.rs

@@ -1,7 +1,6 @@
-use std::fs;
-use std::path::PathBuf;
-
-use red_knot_python_semantic::{HasTy, SemanticModel};
+use red_knot_python_semantic::{
+    HasTy, ProgramSettings, PythonVersion, SearchPathSettings, SemanticModel,
+};
 use red_knot_workspace::db::RootDatabase;
 use red_knot_workspace::workspace::WorkspaceMetadata;
 use ruff_db::files::{system_path_to_file, File};
@@ -10,11 +9,23 @@ use ruff_db::system::{OsSystem, SystemPath, SystemPathBuf};
 use ruff_python_ast::visitor::source_order;
 use ruff_python_ast::visitor::source_order::SourceOrderVisitor;
 use ruff_python_ast::{Alias, Expr, Parameter, ParameterWithDefault, Stmt};
+use std::fs;
+use std::path::PathBuf;
 
-fn setup_db(workspace_root: &SystemPath) -> anyhow::Result<RootDatabase> {
-    let system = OsSystem::new(workspace_root);
-    let workspace = WorkspaceMetadata::from_path(workspace_root, &system, None)?;
-    RootDatabase::new(workspace, system)
+fn setup_db(workspace_root: SystemPathBuf) -> anyhow::Result<RootDatabase> {
+    let system = OsSystem::new(&workspace_root);
+    let workspace = WorkspaceMetadata::from_path(&workspace_root, &system)?;
+    let search_paths = SearchPathSettings {
+        extra_paths: vec![],
+        src_root: workspace_root,
+        custom_typeshed: None,
+        site_packages: vec![],
+    };
+    let settings = ProgramSettings {
+        target_version: PythonVersion::default(),
+        search_paths,
+    };
+    RootDatabase::new(workspace, settings, system)
 }
 
 /// Test that all snippets in testcorpus can be checked without panic
@@ -22,9 +33,8 @@ fn setup_db(workspace_root: &SystemPath) -> anyhow::Result<RootDatabase> {
 #[allow(clippy::print_stdout)]
 fn corpus_no_panic() -> anyhow::Result<()> {
     let corpus = PathBuf::from(env!("CARGO_MANIFEST_DIR")).join("resources/test/corpus");
-    let system_corpus =
-        SystemPathBuf::from_path_buf(corpus.clone()).expect("corpus path to be UTF8");
-    let db = setup_db(&system_corpus)?;
+    let system_corpus = SystemPath::from_std_path(&corpus).expect("corpus path to be UTF8");
+    let db = setup_db(system_corpus.to_path_buf())?;
 
     for path in fs::read_dir(&corpus).expect("corpus to be a directory") {
         let path = path.expect("path to not be an error").path();

crates/ruff/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "ruff"
-version = "0.6.2"
+version = "0.6.1"
 publish = true
 authors = { workspace = true }
 edition = { workspace = true }

crates/ruff_benchmark/benches/red_knot.rs

@@ -1,9 +1,8 @@
 #![allow(clippy::disallowed_names)]
 
-use red_knot_python_semantic::PythonVersion;
+use red_knot_python_semantic::{ProgramSettings, PythonVersion, SearchPathSettings};
 use red_knot_workspace::db::RootDatabase;
 use red_knot_workspace::watch::{ChangeEvent, ChangedKind};
-use red_knot_workspace::workspace::settings::Configuration;
 use red_knot_workspace::workspace::WorkspaceMetadata;
 use ruff_benchmark::criterion::{criterion_group, criterion_main, BatchSize, Criterion};
 use ruff_benchmark::TestFile;
@@ -87,17 +86,18 @@ fn setup_case() -> Case {
     .unwrap();
 
     let src_root = SystemPath::new("/src");
-    let metadata = WorkspaceMetadata::from_path(
-        src_root,
-        &system,
-        Some(Configuration {
-            target_version: Some(PythonVersion::PY312),
-            ..Configuration::default()
-        }),
-    )
-    .unwrap();
+    let metadata = WorkspaceMetadata::from_path(src_root, &system).unwrap();
+    let settings = ProgramSettings {
+        target_version: PythonVersion::PY312,
+        search_paths: SearchPathSettings {
+            extra_paths: vec![],
+            src_root: src_root.to_path_buf(),
+            site_packages: vec![],
+            custom_typeshed: None,
+        },
+    };
 
-    let mut db = RootDatabase::new(metadata, system).unwrap();
+    let mut db = RootDatabase::new(metadata, settings, system).unwrap();
     let parser = system_path_to_file(&db, parser_path).unwrap();
 
     db.workspace().open_file(&mut db, parser);
@@ -131,13 +131,10 @@ fn benchmark_incremental(criterion: &mut Criterion) {
             |case| {
                 let Case { db, .. } = case;
 
-                db.apply_changes(
-                    vec![ChangeEvent::Changed {
-                        path: case.re_path.to_path_buf(),
-                        kind: ChangedKind::FileContent,
-                    }],
-                    None,
-                );
+                db.apply_changes(vec![ChangeEvent::Changed {
+                    path: case.re_path.to_path_buf(),
+                    kind: ChangedKind::FileContent,
+                }]);
 
                 let result = db.check().unwrap();
 

crates/ruff_linter/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "ruff_linter"
-version = "0.6.2"
+version = "0.6.1"
 publish = false
 authors = { workspace = true }
 edition = { workspace = true }

crates/ruff_linter/resources/test/fixtures/flake8_simplify/SIM115.py

@@ -47,6 +47,7 @@ with contextlib.ExitStack() as exit_stack:
 open("filename", "w").close()
 pathlib.Path("filename").open("w").close()
 
+
 # OK (custom context manager)
 class MyFile:
     def __init__(self, filename: str):
@@ -57,189 +58,3 @@ class MyFile:
 
     def __exit__(self, exc_type, exc_val, exc_tb):
         self.file.close()
-
-
-import tempfile
-import tarfile
-from tarfile import TarFile
-import zipfile
-import io
-import codecs
-import bz2
-import gzip
-import dbm
-import dbm.gnu
-import dbm.ndbm
-import dbm.dumb
-import lzma
-import shelve
-import tokenize
-import wave
-import fileinput
-
-f = tempfile.NamedTemporaryFile()
-f = tempfile.TemporaryFile()
-f = tempfile.SpooledTemporaryFile()
-f = tarfile.open("foo.tar")
-f = TarFile("foo.tar").open()
-f = tarfile.TarFile("foo.tar").open()
-f = tarfile.TarFile().open()
-f = zipfile.ZipFile("foo.zip").open("foo.txt")
-f = io.open("foo.txt")
-f = io.open_code("foo.txt")
-f = codecs.open("foo.txt")
-f = bz2.open("foo.txt")
-f = gzip.open("foo.txt")
-f = dbm.open("foo.db")
-f = dbm.gnu.open("foo.db")
-f = dbm.ndbm.open("foo.db")
-f = dbm.dumb.open("foo.db")
-f = lzma.open("foo.xz")
-f = lzma.LZMAFile("foo.xz")
-f = shelve.open("foo.db")
-f = tokenize.open("foo.py")
-f = wave.open("foo.wav")
-f = tarfile.TarFile.taropen("foo.tar")
-f = fileinput.input("foo.txt")
-f = fileinput.FileInput("foo.txt")
-
-with contextlib.suppress(Exception):
-    # The following line is for example's sake.
-    # For some f's above, this would raise an error (since it'd be f.readline() etc.)
-    data = f.read()
-
-f.close()
-
-# OK
-with tempfile.TemporaryFile() as f:
-    data = f.read()
-
-# OK
-with tarfile.open("foo.tar") as f:
-    data = f.add("foo.txt")
-
-# OK
-with tarfile.TarFile("foo.tar") as f:
-    data = f.add("foo.txt")
-
-# OK
-with tarfile.TarFile("foo.tar").open() as f:
-    data = f.add("foo.txt")
-
-# OK
-with zipfile.ZipFile("foo.zip") as f:
-    data = f.read("foo.txt")
-
-# OK
-with zipfile.ZipFile("foo.zip").open("foo.txt") as f:
-    data = f.read()
-
-# OK
-with zipfile.ZipFile("foo.zip") as zf:
-    with zf.open("foo.txt") as f:
-        data = f.read()
-
-# OK
-with io.open("foo.txt") as f:
-    data = f.read()
-
-# OK
-with io.open_code("foo.txt") as f:
-    data = f.read()
-
-# OK
-with codecs.open("foo.txt") as f:
-    data = f.read()
-
-# OK
-with bz2.open("foo.txt") as f:
-    data = f.read()
-
-# OK
-with gzip.open("foo.txt") as f:
-    data = f.read()
-
-# OK
-with dbm.open("foo.db") as f:
-    data = f.get("foo")
-
-# OK
-with dbm.gnu.open("foo.db") as f:
-    data = f.get("foo")
-
-# OK
-with dbm.ndbm.open("foo.db") as f:
-    data = f.get("foo")
-
-# OK
-with dbm.dumb.open("foo.db") as f:
-    data = f.get("foo")
-
-# OK
-with lzma.open("foo.xz") as f:
-    data = f.read()
-
-# OK
-with lzma.LZMAFile("foo.xz") as f:
-    data = f.read()
-
-# OK
-with shelve.open("foo.db") as f:
-    data = f["foo"]
-
-# OK
-with tokenize.open("foo.py") as f:
-    data = f.read()
-
-# OK
-with wave.open("foo.wav") as f:
-    data = f.readframes(1024)
-
-# OK
-with tarfile.TarFile.taropen("foo.tar") as f:
-    data = f.add("foo.txt")
-
-# OK
-with fileinput.input("foo.txt") as f:
-    data = f.readline()
-
-# OK
-with fileinput.FileInput("foo.txt") as f:
-    data = f.readline()
-
-# OK (quick one-liner to clear file contents)
-tempfile.NamedTemporaryFile().close()
-tempfile.TemporaryFile().close()
-tempfile.SpooledTemporaryFile().close()
-tarfile.open("foo.tar").close()
-tarfile.TarFile("foo.tar").close()
-tarfile.TarFile("foo.tar").open().close()
-tarfile.TarFile.open("foo.tar").close()
-zipfile.ZipFile("foo.zip").close()
-zipfile.ZipFile("foo.zip").open("foo.txt").close()
-io.open("foo.txt").close()
-io.open_code("foo.txt").close()
-codecs.open("foo.txt").close()
-bz2.open("foo.txt").close()
-gzip.open("foo.txt").close()
-dbm.open("foo.db").close()
-dbm.gnu.open("foo.db").close()
-dbm.ndbm.open("foo.db").close()
-dbm.dumb.open("foo.db").close()
-lzma.open("foo.xz").close()
-lzma.LZMAFile("foo.xz").close()
-shelve.open("foo.db").close()
-tokenize.open("foo.py").close()
-wave.open("foo.wav").close()
-tarfile.TarFile.taropen("foo.tar").close()
-fileinput.input("foo.txt").close()
-fileinput.FileInput("foo.txt").close()
-
-def aliased():
-    from shelve import open as open_shelf
-    x = open_shelf("foo.dbm")
-    x.close()
-
-    from tarfile import TarFile as TF
-    f = TF("foo").open()
-    f.close()

crates/ruff_linter/src/checkers/ast/analyze/expression.rs

@@ -883,7 +883,7 @@ pub(crate) fn expression(expr: &Expr, checker: &mut Checker) {
                 flake8_simplify::rules::use_capital_environment_variables(checker, expr);
             }
             if checker.enabled(Rule::OpenFileWithContextHandler) {
-                flake8_simplify::rules::open_file_with_context_handler(checker, call);
+                flake8_simplify::rules::open_file_with_context_handler(checker, func);
             }
             if checker.enabled(Rule::DictGetWithNoneDefault) {
                 flake8_simplify::rules::dict_get_with_none_default(checker, expr);

crates/ruff_linter/src/rules/flake8_simplify/mod.rs

@@ -58,7 +58,6 @@ mod tests {
     }
 
     #[test_case(Rule::IfElseBlockInsteadOfIfExp, Path::new("SIM108.py"))]
-    #[test_case(Rule::OpenFileWithContextHandler, Path::new("SIM115.py"))]
     fn preview_rules(rule_code: Rule, path: &Path) -> Result<()> {
         let snapshot = format!(
             "preview__{}_{}",

crates/ruff_linter/src/rules/flake8_simplify/rules/open_file_with_context_handler.rs

@@ -8,20 +8,14 @@ use ruff_text_size::Ranged;
 use crate::checkers::ast::Checker;
 
 /// ## What it does
-/// Checks for cases where files are opened (e.g., using the builtin `open()` function)
-/// without using a context manager.
+/// Checks for uses of the builtin `open()` function without an associated context
+/// manager.
 ///
 /// ## Why is this bad?
 /// If a file is opened without a context manager, it is not guaranteed that
 /// the file will be closed (e.g., if an exception is raised), which can cause
 /// resource leaks.
 ///
-/// ## Preview-mode behavior
-/// If [preview] mode is enabled, this rule will detect a wide array of IO calls where
-/// context managers could be used, such as `tempfile.TemporaryFile()` or
-/// `tarfile.TarFile(...).gzopen()`. If preview mode is not enabled, only `open()`,
-/// `builtins.open()` and `pathlib.Path(...).open()` are detected.
-///
 /// ## Example
 /// ```python
 /// file = open("foo.txt")
@@ -43,7 +37,7 @@ pub struct OpenFileWithContextHandler;
 impl Violation for OpenFileWithContextHandler {
     #[derive_message_formats]
     fn message(&self) -> String {
-        format!("Use a context manager for opening files")
+        format!("Use context handler for opening files")
     }
 }
 
@@ -119,14 +113,14 @@ fn match_exit_stack(semantic: &SemanticModel) -> bool {
 }
 
 /// Return `true` if `func` is the builtin `open` or `pathlib.Path(...).open`.
-fn is_open(semantic: &SemanticModel, call: &ast::ExprCall) -> bool {
+fn is_open(semantic: &SemanticModel, func: &Expr) -> bool {
     // Ex) `open(...)`
-    if semantic.match_builtin_expr(&call.func, "open") {
+    if semantic.match_builtin_expr(func, "open") {
         return true;
     }
 
     // Ex) `pathlib.Path(...).open()`
-    let Expr::Attribute(ast::ExprAttribute { attr, value, .. }) = &*call.func else {
+    let Expr::Attribute(ast::ExprAttribute { attr, value, .. }) = func else {
         return false;
     };
 
@@ -146,63 +140,6 @@ fn is_open(semantic: &SemanticModel, call: &ast::ExprCall) -> bool {
         .is_some_and(|qualified_name| matches!(qualified_name.segments(), ["pathlib", "Path"]))
 }
 
-/// Return `true` if the expression is an `open` call or temporary file constructor.
-fn is_open_preview(semantic: &SemanticModel, call: &ast::ExprCall) -> bool {
-    let func = &*call.func;
-
-    // Ex) `open(...)`
-    if let Some(qualified_name) = semantic.resolve_qualified_name(func) {
-        return matches!(
-            qualified_name.segments(),
-            [
-                "" | "builtins"
-                    | "bz2"
-                    | "codecs"
-                    | "dbm"
-                    | "gzip"
-                    | "tarfile"
-                    | "shelve"
-                    | "tokenize"
-                    | "wave",
-                "open"
-            ] | ["dbm", "gnu" | "ndbm" | "dumb", "open"]
-                | ["fileinput", "FileInput" | "input"]
-                | ["io", "open" | "open_code"]
-                | ["lzma", "LZMAFile" | "open"]
-                | ["tarfile", "TarFile", "taropen"]
-                | [
-                    "tempfile",
-                    "TemporaryFile" | "NamedTemporaryFile" | "SpooledTemporaryFile"
-                ]
-        );
-    }
-
-    // Ex) `pathlib.Path(...).open()`
-    let Expr::Attribute(ast::ExprAttribute { attr, value, .. }) = func else {
-        return false;
-    };
-
-    let Expr::Call(ast::ExprCall { func, .. }) = &**value else {
-        return false;
-    };
-
-    // E.g. for `pathlib.Path(...).open()`, `qualified_name_of_instance.segments() == ["pathlib", "Path"]`
-    let Some(qualified_name_of_instance) = semantic.resolve_qualified_name(func) else {
-        return false;
-    };
-
-    matches!(
-        (qualified_name_of_instance.segments(), &**attr),
-        (
-            ["pathlib", "Path"] | ["zipfile", "ZipFile"] | ["lzma", "LZMAFile"],
-            "open"
-        ) | (
-            ["tarfile", "TarFile"],
-            "open" | "taropen" | "gzopen" | "bz2open" | "xzopen"
-        )
-    )
-}
-
 /// Return `true` if the current expression is followed by a `close` call.
 fn is_closed(semantic: &SemanticModel) -> bool {
     let Some(expr) = semantic.current_expression_grandparent() else {
@@ -228,17 +165,11 @@ fn is_closed(semantic: &SemanticModel) -> bool {
 }
 
 /// SIM115
-pub(crate) fn open_file_with_context_handler(checker: &mut Checker, call: &ast::ExprCall) {
+pub(crate) fn open_file_with_context_handler(checker: &mut Checker, func: &Expr) {
     let semantic = checker.semantic();
 
-    if checker.settings.preview.is_disabled() {
-        if !is_open(semantic, call) {
-            return;
-        }
-    } else {
-        if !is_open_preview(semantic, call) {
-            return;
-        }
+    if !is_open(semantic, func) {
+        return;
     }
 
     // Ex) `open("foo.txt").close()`
@@ -270,8 +201,7 @@ pub(crate) fn open_file_with_context_handler(checker: &mut Checker, call: &ast::
         }
     }
 
-    checker.diagnostics.push(Diagnostic::new(
-        OpenFileWithContextHandler,
-        call.func.range(),
-    ));
+    checker
+        .diagnostics
+        .push(Diagnostic::new(OpenFileWithContextHandler, func.range()));
 }

crates/ruff_linter/src/rules/flake8_simplify/snapshots/ruff_linter__rules__flake8_simplify__tests__SIM115_SIM115.py.snap

@@ -1,7 +1,7 @@
 ---
 source: crates/ruff_linter/src/rules/flake8_simplify/mod.rs
 ---
-SIM115.py:8:5: SIM115 Use a context manager for opening files
+SIM115.py:8:5: SIM115 Use context handler for opening files
    |
  7 | # SIM115
  8 | f = open("foo.txt")
@@ -10,7 +10,7 @@ SIM115.py:8:5: SIM115 Use a context manager for opening files
 10 | f = pathlib.Path("foo.txt").open()
    |
 
-SIM115.py:9:5: SIM115 Use a context manager for opening files
+SIM115.py:9:5: SIM115 Use context handler for opening files
    |
  7 | # SIM115
  8 | f = open("foo.txt")
@@ -20,7 +20,7 @@ SIM115.py:9:5: SIM115 Use a context manager for opening files
 11 | f = pl.Path("foo.txt").open()
    |
 
-SIM115.py:10:5: SIM115 Use a context manager for opening files
+SIM115.py:10:5: SIM115 Use context handler for opening files
    |
  8 | f = open("foo.txt")
  9 | f = Path("foo.txt").open()
@@ -30,7 +30,7 @@ SIM115.py:10:5: SIM115 Use a context manager for opening files
 12 | f = P("foo.txt").open()
    |
 
-SIM115.py:11:5: SIM115 Use a context manager for opening files
+SIM115.py:11:5: SIM115 Use context handler for opening files
    |
  9 | f = Path("foo.txt").open()
 10 | f = pathlib.Path("foo.txt").open()
@@ -40,7 +40,7 @@ SIM115.py:11:5: SIM115 Use a context manager for opening files
 13 | data = f.read()
    |
 
-SIM115.py:12:5: SIM115 Use a context manager for opening files
+SIM115.py:12:5: SIM115 Use context handler for opening files
    |
 10 | f = pathlib.Path("foo.txt").open()
 11 | f = pl.Path("foo.txt").open()
@@ -50,7 +50,7 @@ SIM115.py:12:5: SIM115 Use a context manager for opening files
 14 | f.close()
    |
 
-SIM115.py:39:9: SIM115 Use a context manager for opening files
+SIM115.py:39:9: SIM115 Use context handler for opening files
    |
 37 | # SIM115
 38 | with contextlib.ExitStack():
@@ -59,3 +59,5 @@ SIM115.py:39:9: SIM115 Use a context manager for opening files
 40 | 
 41 | # OK
    |
+
+

crates/ruff_linter/src/rules/flake8_simplify/snapshots/ruff_linter__rules__flake8_simplify__tests__preview__SIM115_SIM115.py.snap

@@ -1,326 +0,0 @@
----
-source: crates/ruff_linter/src/rules/flake8_simplify/mod.rs
----
-SIM115.py:8:5: SIM115 Use a context manager for opening files
-   |
- 7 | # SIM115
- 8 | f = open("foo.txt")
-   |     ^^^^ SIM115
- 9 | f = Path("foo.txt").open()
-10 | f = pathlib.Path("foo.txt").open()
-   |
-
-SIM115.py:9:5: SIM115 Use a context manager for opening files
-   |
- 7 | # SIM115
- 8 | f = open("foo.txt")
- 9 | f = Path("foo.txt").open()
-   |     ^^^^^^^^^^^^^^^^^^^^ SIM115
-10 | f = pathlib.Path("foo.txt").open()
-11 | f = pl.Path("foo.txt").open()
-   |
-
-SIM115.py:10:5: SIM115 Use a context manager for opening files
-   |
- 8 | f = open("foo.txt")
- 9 | f = Path("foo.txt").open()
-10 | f = pathlib.Path("foo.txt").open()
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ SIM115
-11 | f = pl.Path("foo.txt").open()
-12 | f = P("foo.txt").open()
-   |
-
-SIM115.py:11:5: SIM115 Use a context manager for opening files
-   |
- 9 | f = Path("foo.txt").open()
-10 | f = pathlib.Path("foo.txt").open()
-11 | f = pl.Path("foo.txt").open()
-   |     ^^^^^^^^^^^^^^^^^^^^^^^ SIM115
-12 | f = P("foo.txt").open()
-13 | data = f.read()
-   |
-
-SIM115.py:12:5: SIM115 Use a context manager for opening files
-   |
-10 | f = pathlib.Path("foo.txt").open()
-11 | f = pl.Path("foo.txt").open()
-12 | f = P("foo.txt").open()
-   |     ^^^^^^^^^^^^^^^^^ SIM115
-13 | data = f.read()
-14 | f.close()
-   |
-
-SIM115.py:39:9: SIM115 Use a context manager for opening files
-   |
-37 | # SIM115
-38 | with contextlib.ExitStack():
-39 |     f = open("filename")
-   |         ^^^^ SIM115
-40 | 
-41 | # OK
-   |
-
-SIM115.py:80:5: SIM115 Use a context manager for opening files
-   |
-78 | import fileinput
-79 | 
-80 | f = tempfile.NamedTemporaryFile()
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^ SIM115
-81 | f = tempfile.TemporaryFile()
-82 | f = tempfile.SpooledTemporaryFile()
-   |
-
-SIM115.py:81:5: SIM115 Use a context manager for opening files
-   |
-80 | f = tempfile.NamedTemporaryFile()
-81 | f = tempfile.TemporaryFile()
-   |     ^^^^^^^^^^^^^^^^^^^^^^ SIM115
-82 | f = tempfile.SpooledTemporaryFile()
-83 | f = tarfile.open("foo.tar")
-   |
-
-SIM115.py:82:5: SIM115 Use a context manager for opening files
-   |
-80 | f = tempfile.NamedTemporaryFile()
-81 | f = tempfile.TemporaryFile()
-82 | f = tempfile.SpooledTemporaryFile()
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ SIM115
-83 | f = tarfile.open("foo.tar")
-84 | f = TarFile("foo.tar").open()
-   |
-
-SIM115.py:83:5: SIM115 Use a context manager for opening files
-   |
-81 | f = tempfile.TemporaryFile()
-82 | f = tempfile.SpooledTemporaryFile()
-83 | f = tarfile.open("foo.tar")
-   |     ^^^^^^^^^^^^ SIM115
-84 | f = TarFile("foo.tar").open()
-85 | f = tarfile.TarFile("foo.tar").open()
-   |
-
-SIM115.py:84:5: SIM115 Use a context manager for opening files
-   |
-82 | f = tempfile.SpooledTemporaryFile()
-83 | f = tarfile.open("foo.tar")
-84 | f = TarFile("foo.tar").open()
-   |     ^^^^^^^^^^^^^^^^^^^^^^^ SIM115
-85 | f = tarfile.TarFile("foo.tar").open()
-86 | f = tarfile.TarFile().open()
-   |
-
-SIM115.py:85:5: SIM115 Use a context manager for opening files
-   |
-83 | f = tarfile.open("foo.tar")
-84 | f = TarFile("foo.tar").open()
-85 | f = tarfile.TarFile("foo.tar").open()
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ SIM115
-86 | f = tarfile.TarFile().open()
-87 | f = zipfile.ZipFile("foo.zip").open("foo.txt")
-   |
-
-SIM115.py:86:5: SIM115 Use a context manager for opening files
-   |
-84 | f = TarFile("foo.tar").open()
-85 | f = tarfile.TarFile("foo.tar").open()
-86 | f = tarfile.TarFile().open()
-   |     ^^^^^^^^^^^^^^^^^^^^^^ SIM115
-87 | f = zipfile.ZipFile("foo.zip").open("foo.txt")
-88 | f = io.open("foo.txt")
-   |
-
-SIM115.py:87:5: SIM115 Use a context manager for opening files
-   |
-85 | f = tarfile.TarFile("foo.tar").open()
-86 | f = tarfile.TarFile().open()
-87 | f = zipfile.ZipFile("foo.zip").open("foo.txt")
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ SIM115
-88 | f = io.open("foo.txt")
-89 | f = io.open_code("foo.txt")
-   |
-
-SIM115.py:88:5: SIM115 Use a context manager for opening files
-   |
-86 | f = tarfile.TarFile().open()
-87 | f = zipfile.ZipFile("foo.zip").open("foo.txt")
-88 | f = io.open("foo.txt")
-   |     ^^^^^^^ SIM115
-89 | f = io.open_code("foo.txt")
-90 | f = codecs.open("foo.txt")
-   |
-
-SIM115.py:89:5: SIM115 Use a context manager for opening files
-   |
-87 | f = zipfile.ZipFile("foo.zip").open("foo.txt")
-88 | f = io.open("foo.txt")
-89 | f = io.open_code("foo.txt")
-   |     ^^^^^^^^^^^^ SIM115
-90 | f = codecs.open("foo.txt")
-91 | f = bz2.open("foo.txt")
-   |
-
-SIM115.py:90:5: SIM115 Use a context manager for opening files
-   |
-88 | f = io.open("foo.txt")
-89 | f = io.open_code("foo.txt")
-90 | f = codecs.open("foo.txt")
-   |     ^^^^^^^^^^^ SIM115
-91 | f = bz2.open("foo.txt")
-92 | f = gzip.open("foo.txt")
-   |
-
-SIM115.py:91:5: SIM115 Use a context manager for opening files
-   |
-89 | f = io.open_code("foo.txt")
-90 | f = codecs.open("foo.txt")
-91 | f = bz2.open("foo.txt")
-   |     ^^^^^^^^ SIM115
-92 | f = gzip.open("foo.txt")
-93 | f = dbm.open("foo.db")
-   |
-
-SIM115.py:92:5: SIM115 Use a context manager for opening files
-   |
-90 | f = codecs.open("foo.txt")
-91 | f = bz2.open("foo.txt")
-92 | f = gzip.open("foo.txt")
-   |     ^^^^^^^^^ SIM115
-93 | f = dbm.open("foo.db")
-94 | f = dbm.gnu.open("foo.db")
-   |
-
-SIM115.py:93:5: SIM115 Use a context manager for opening files
-   |
-91 | f = bz2.open("foo.txt")
-92 | f = gzip.open("foo.txt")
-93 | f = dbm.open("foo.db")
-   |     ^^^^^^^^ SIM115
-94 | f = dbm.gnu.open("foo.db")
-95 | f = dbm.ndbm.open("foo.db")
-   |
-
-SIM115.py:94:5: SIM115 Use a context manager for opening files
-   |
-92 | f = gzip.open("foo.txt")
-93 | f = dbm.open("foo.db")
-94 | f = dbm.gnu.open("foo.db")
-   |     ^^^^^^^^^^^^ SIM115
-95 | f = dbm.ndbm.open("foo.db")
-96 | f = dbm.dumb.open("foo.db")
-   |
-
-SIM115.py:95:5: SIM115 Use a context manager for opening files
-   |
-93 | f = dbm.open("foo.db")
-94 | f = dbm.gnu.open("foo.db")
-95 | f = dbm.ndbm.open("foo.db")
-   |     ^^^^^^^^^^^^^ SIM115
-96 | f = dbm.dumb.open("foo.db")
-97 | f = lzma.open("foo.xz")
-   |
-
-SIM115.py:96:5: SIM115 Use a context manager for opening files
-   |
-94 | f = dbm.gnu.open("foo.db")
-95 | f = dbm.ndbm.open("foo.db")
-96 | f = dbm.dumb.open("foo.db")
-   |     ^^^^^^^^^^^^^ SIM115
-97 | f = lzma.open("foo.xz")
-98 | f = lzma.LZMAFile("foo.xz")
-   |
-
-SIM115.py:97:5: SIM115 Use a context manager for opening files
-   |
-95 | f = dbm.ndbm.open("foo.db")
-96 | f = dbm.dumb.open("foo.db")
-97 | f = lzma.open("foo.xz")
-   |     ^^^^^^^^^ SIM115
-98 | f = lzma.LZMAFile("foo.xz")
-99 | f = shelve.open("foo.db")
-   |
-
-SIM115.py:98:5: SIM115 Use a context manager for opening files
-    |
- 96 | f = dbm.dumb.open("foo.db")
- 97 | f = lzma.open("foo.xz")
- 98 | f = lzma.LZMAFile("foo.xz")
-    |     ^^^^^^^^^^^^^ SIM115
- 99 | f = shelve.open("foo.db")
-100 | f = tokenize.open("foo.py")
-    |
-
-SIM115.py:99:5: SIM115 Use a context manager for opening files
-    |
- 97 | f = lzma.open("foo.xz")
- 98 | f = lzma.LZMAFile("foo.xz")
- 99 | f = shelve.open("foo.db")
-    |     ^^^^^^^^^^^ SIM115
-100 | f = tokenize.open("foo.py")
-101 | f = wave.open("foo.wav")
-    |
-
-SIM115.py:100:5: SIM115 Use a context manager for opening files
-    |
- 98 | f = lzma.LZMAFile("foo.xz")
- 99 | f = shelve.open("foo.db")
-100 | f = tokenize.open("foo.py")
-    |     ^^^^^^^^^^^^^ SIM115
-101 | f = wave.open("foo.wav")
-102 | f = tarfile.TarFile.taropen("foo.tar")
-    |
-
-SIM115.py:101:5: SIM115 Use a context manager for opening files
-    |
- 99 | f = shelve.open("foo.db")
-100 | f = tokenize.open("foo.py")
-101 | f = wave.open("foo.wav")
-    |     ^^^^^^^^^ SIM115
-102 | f = tarfile.TarFile.taropen("foo.tar")
-103 | f = fileinput.input("foo.txt")
-    |
-
-SIM115.py:102:5: SIM115 Use a context manager for opening files
-    |
-100 | f = tokenize.open("foo.py")
-101 | f = wave.open("foo.wav")
-102 | f = tarfile.TarFile.taropen("foo.tar")
-    |     ^^^^^^^^^^^^^^^^^^^^^^^ SIM115
-103 | f = fileinput.input("foo.txt")
-104 | f = fileinput.FileInput("foo.txt")
-    |
-
-SIM115.py:103:5: SIM115 Use a context manager for opening files
-    |
-101 | f = wave.open("foo.wav")
-102 | f = tarfile.TarFile.taropen("foo.tar")
-103 | f = fileinput.input("foo.txt")
-    |     ^^^^^^^^^^^^^^^ SIM115
-104 | f = fileinput.FileInput("foo.txt")
-    |
-
-SIM115.py:104:5: SIM115 Use a context manager for opening files
-    |
-102 | f = tarfile.TarFile.taropen("foo.tar")
-103 | f = fileinput.input("foo.txt")
-104 | f = fileinput.FileInput("foo.txt")
-    |     ^^^^^^^^^^^^^^^^^^^ SIM115
-105 | 
-106 | with contextlib.suppress(Exception):
-    |
-
-SIM115.py:240:9: SIM115 Use a context manager for opening files
-    |
-238 | def aliased():
-239 |     from shelve import open as open_shelf
-240 |     x = open_shelf("foo.dbm")
-    |         ^^^^^^^^^^ SIM115
-241 |     x.close()
-    |
-
-SIM115.py:244:9: SIM115 Use a context manager for opening files
-    |
-243 |     from tarfile import TarFile as TF
-244 |     f = TF("foo").open()
-    |         ^^^^^^^^^^^^^^ SIM115
-245 |     f.close()
-    |

crates/ruff_wasm/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "ruff_wasm"
-version = "0.6.2"
+version = "0.6.1"
 publish = false
 authors = { workspace = true }
 edition = { workspace = true }

crates/ruff_workspace/src/resolver.rs

@@ -253,7 +253,7 @@ fn is_package_with_cache<'a>(
 /// Applies a transformation to a [`Configuration`].
 ///
 /// Used to override options with the values provided by the CLI.
-pub trait ConfigurationTransformer {
+pub trait ConfigurationTransformer: Sync {
     fn transform(&self, config: Configuration) -> Configuration;
 }
 
@@ -334,7 +334,7 @@ pub fn resolve_root_settings(
 pub fn python_files_in_path<'a>(
     paths: &[PathBuf],
     pyproject_config: &'a PyprojectConfig,
-    transformer: &(dyn ConfigurationTransformer + Sync),
+    transformer: &dyn ConfigurationTransformer,
 ) -> Result<(Vec<Result<ResolvedFile, ignore::Error>>, Resolver<'a>)> {
     // Normalize every path (e.g., convert from relative to absolute).
     let mut paths: Vec<PathBuf> = paths.iter().map(fs::normalize_path).unique().collect();
@@ -430,12 +430,12 @@ impl<'config> WalkPythonFilesState<'config> {
 
 struct PythonFilesVisitorBuilder<'s, 'config> {
     state: &'s WalkPythonFilesState<'config>,
-    transformer: &'s (dyn ConfigurationTransformer + Sync),
+    transformer: &'s dyn ConfigurationTransformer,
 }
 
 impl<'s, 'config> PythonFilesVisitorBuilder<'s, 'config> {
     fn new(
-        transformer: &'s (dyn ConfigurationTransformer + Sync),
+        transformer: &'s dyn ConfigurationTransformer,
         state: &'s WalkPythonFilesState<'config>,
     ) -> Self {
         Self { state, transformer }
@@ -446,7 +446,7 @@ struct PythonFilesVisitor<'s, 'config> {
     local_files: Vec<Result<ResolvedFile, ignore::Error>>,
     local_error: Result<()>,
     global: &'s WalkPythonFilesState<'config>,
-    transformer: &'s (dyn ConfigurationTransformer + Sync),
+    transformer: &'s dyn ConfigurationTransformer,
 }
 
 impl<'config, 's> ignore::ParallelVisitorBuilder<'s> for PythonFilesVisitorBuilder<'s, 'config>

docs/integrations.md

@@ -78,7 +78,7 @@ Ruff can be used as a [pre-commit](https://pre-commit.com) hook via [`ruff-pre-c
 ```yaml
 - repo: https://github.com/astral-sh/ruff-pre-commit
   # Ruff version.
-  rev: v0.6.2
+  rev: v0.6.1
   hooks:
     # Run the linter.
     - id: ruff
@@ -91,7 +91,7 @@ To enable lint fixes, add the `--fix` argument to the lint hook:
 ```yaml
 - repo: https://github.com/astral-sh/ruff-pre-commit
   # Ruff version.
-  rev: v0.6.2
+  rev: v0.6.1
   hooks:
     # Run the linter.
     - id: ruff
@@ -105,7 +105,7 @@ To run the hooks over Jupyter Notebooks too, add `jupyter` to the list of allowe
 ```yaml
 - repo: https://github.com/astral-sh/ruff-pre-commit
   # Ruff version.
-  rev: v0.6.2
+  rev: v0.6.1
   hooks:
     # Run the linter.
     - id: ruff

pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "maturin"
 
 [project]
 name = "ruff"
-version = "0.6.2"
+version = "0.6.1"
 description = "An extremely fast Python linter and code formatter, written in Rust."
 authors = [{ name = "Astral Software Inc.", email = "hey@astral.sh" }]
 readme = "README.md"

scripts/benchmarks/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "scripts"
-version = "0.6.2"
+version = "0.6.1"
 description = ""
 authors = ["Charles Marsh <charlie.r.marsh@gmail.com>"]