Move Program and related structs to red_knot_python_semantic (#12777)

crates/red_knot_python_semantic/src/lib.rs

@@ -5,6 +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, TargetVersion};
 pub use semantic_model::{HasTy, SemanticModel};
 
 pub mod ast_node_ref;
@@ -13,6 +14,7 @@ mod db;
 mod module_name;
 mod module_resolver;
 mod node_key;
+mod program;
 pub mod semantic_index;
 mod semantic_model;
 pub mod types;

crates/red_knot_python_semantic/src/module_resolver/path.rs

@@ -620,14 +620,13 @@ impl PartialEq<SearchPath> for VendoredPathBuf {
 
 #[cfg(test)]
 mod tests {
-    use ruff_db::program::TargetVersion;
     use ruff_db::Db;
 
     use crate::db::tests::TestDb;
 
-    use crate::module_resolver::testing::{FileSpec, MockedTypeshed, TestCase, TestCaseBuilder};
-
     use super::*;
+    use crate::module_resolver::testing::{FileSpec, MockedTypeshed, TestCase, TestCaseBuilder};
+    use crate::TargetVersion;
 
     impl ModulePath {
         #[must_use]

crates/red_knot_python_semantic/src/module_resolver/resolver.rs

@@ -1,18 +1,18 @@
 use std::borrow::Cow;
 use std::iter::FusedIterator;
 
-use ruff_db::files::{File, FilePath, FileRootKind};
-use ruff_db::program::{Program, SearchPathSettings, TargetVersion};
-use ruff_db::system::{DirectoryEntry, System, SystemPath, SystemPathBuf};
-use ruff_db::vendored::VendoredPath;
 use rustc_hash::{FxBuildHasher, FxHashSet};
 
-use crate::db::Db;
-use crate::module_name::ModuleName;
+use ruff_db::files::{File, FilePath, FileRootKind};
+use ruff_db::system::{DirectoryEntry, System, SystemPath, SystemPathBuf};
+use ruff_db::vendored::VendoredPath;
 
 use super::module::{Module, ModuleKind};
 use super::path::{ModulePath, SearchPath, SearchPathValidationError};
 use super::state::ResolverState;
+use crate::db::Db;
+use crate::module_name::ModuleName;
+use crate::{Program, SearchPathSettings, TargetVersion};
 
 /// Resolves a module name to a module.
 pub fn resolve_module(db: &dyn Db, module_name: ModuleName) -> Option<Module> {
@@ -1143,7 +1143,7 @@ mod tests {
     fn symlink() -> anyhow::Result<()> {
         use anyhow::Context;
 
-        use ruff_db::program::Program;
+        use crate::program::Program;
         use ruff_db::system::{OsSystem, SystemPath};
 
         use crate::db::tests::TestDb;

crates/red_knot_python_semantic/src/module_resolver/state.rs

@@ -1,8 +1,8 @@
-use ruff_db::program::TargetVersion;
 use ruff_db::vendored::VendoredFileSystem;
 
 use super::typeshed::LazyTypeshedVersions;
 use crate::db::Db;
+use crate::TargetVersion;
 
 pub(crate) struct ResolverState<'db> {
     pub(crate) db: &'db dyn Db,

crates/red_knot_python_semantic/src/module_resolver/testing.rs

@@ -1,8 +1,8 @@
-use ruff_db::program::{Program, SearchPathSettings, TargetVersion};
 use ruff_db::system::{DbWithTestSystem, SystemPath, SystemPathBuf};
 use ruff_db::vendored::VendoredPathBuf;
 
 use crate::db::tests::TestDb;
+use crate::program::{Program, SearchPathSettings, TargetVersion};
 
 /// A test case for the module resolver.
 ///

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

@@ -6,16 +6,15 @@ use std::ops::{RangeFrom, RangeInclusive};
 use std::str::FromStr;
 
 use once_cell::sync::Lazy;
-use ruff_db::program::TargetVersion;
 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 super::vendored::vendored_typeshed_stubs;
+use crate::TargetVersion;
 
 #[derive(Debug)]
 pub(crate) struct LazyTypeshedVersions<'db>(OnceCell<&'db TypeshedVersions>);
@@ -440,7 +439,6 @@ mod tests {
     use std::path::Path;
 
     use insta::assert_snapshot;
-    use ruff_db::program::TargetVersion;
 
     use super::*;
 

crates/red_knot_python_semantic/src/program.rs

@@ -0,0 +1,98 @@
+use crate::Db;
+use ruff_db::system::SystemPathBuf;
+use salsa::Durability;
+
+#[salsa::input(singleton)]
+pub struct Program {
+    pub target_version: TargetVersion,
+
+    #[return_ref]
+    pub search_paths: SearchPathSettings,
+}
+
+impl Program {
+    pub fn from_settings(db: &dyn Db, settings: ProgramSettings) -> Self {
+        Program::builder(settings.target_version, settings.search_paths)
+            .durability(Durability::HIGH)
+            .new(db)
+    }
+}
+
+#[derive(Debug, Eq, PartialEq)]
+pub struct ProgramSettings {
+    pub target_version: TargetVersion,
+    pub search_paths: SearchPathSettings,
+}
+
+/// Enumeration of all supported Python versions
+///
+/// TODO: unify with the `PythonVersion` enum in the linter/formatter crates?
+#[derive(Copy, Clone, Hash, PartialEq, Eq, PartialOrd, Ord, Default)]
+pub enum TargetVersion {
+    Py37,
+    #[default]
+    Py38,
+    Py39,
+    Py310,
+    Py311,
+    Py312,
+    Py313,
+}
+
+impl TargetVersion {
+    pub const fn as_tuple(self) -> (u8, u8) {
+        match self {
+            Self::Py37 => (3, 7),
+            Self::Py38 => (3, 8),
+            Self::Py39 => (3, 9),
+            Self::Py310 => (3, 10),
+            Self::Py311 => (3, 11),
+            Self::Py312 => (3, 12),
+            Self::Py313 => (3, 13),
+        }
+    }
+
+    const fn as_str(self) -> &'static str {
+        match self {
+            Self::Py37 => "py37",
+            Self::Py38 => "py38",
+            Self::Py39 => "py39",
+            Self::Py310 => "py310",
+            Self::Py311 => "py311",
+            Self::Py312 => "py312",
+            Self::Py313 => "py313",
+        }
+    }
+}
+
+impl std::fmt::Display for TargetVersion {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        f.write_str(self.as_str())
+    }
+}
+
+impl std::fmt::Debug for TargetVersion {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        std::fmt::Display::fmt(self, f)
+    }
+}
+
+/// Configures the search paths for module resolution.
+#[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,
+    /// or pyright's stubPath configuration setting.
+    pub extra_paths: Vec<SystemPathBuf>,
+
+    /// The root of the workspace, used for finding first-party modules.
+    pub src_root: 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: Vec<SystemPathBuf>,
+}

crates/red_knot_python_semantic/src/semantic_model.rs

@@ -165,10 +165,10 @@ impl HasTy for ast::Alias {
 mod tests {
     use ruff_db::files::system_path_to_file;
     use ruff_db::parsed::parsed_module;
-    use ruff_db::program::{Program, SearchPathSettings, TargetVersion};
     use ruff_db::system::{DbWithTestSystem, SystemPathBuf};
 
     use crate::db::tests::TestDb;
+    use crate::program::{Program, SearchPathSettings, TargetVersion};
     use crate::types::Type;
     use crate::{HasTy, SemanticModel};
 

crates/red_knot_python_semantic/src/types/infer.rs

@@ -1496,13 +1496,13 @@ impl<'db> TypeInferenceBuilder<'db> {
 mod tests {
     use ruff_db::files::{system_path_to_file, File};
     use ruff_db::parsed::parsed_module;
-    use ruff_db::program::{Program, SearchPathSettings, TargetVersion};
     use ruff_db::system::{DbWithTestSystem, SystemPathBuf};
     use ruff_db::testing::assert_function_query_was_not_run;
     use ruff_python_ast::name::Name;
 
     use crate::builtins::builtins_scope;
     use crate::db::tests::TestDb;
+    use crate::program::{Program, SearchPathSettings, TargetVersion};
     use crate::semantic_index::definition::Definition;
     use crate::semantic_index::symbol::FileScopeId;
     use crate::semantic_index::{global_scope, semantic_index, symbol_table, use_def_map};