Check a module in the Python environment it is imported from

In file mode and the language server, each file gets the config of its
location. A library installed editable into an app's environment, but
with its own config and environment, then resolves its imports in its
own environment, and the app sees two copies of the same package
(#3556). Project mode does not have this problem, because it uses one
config for every file.

`SysInfo` now also carries the site-package path of the environment.
It is part of the `Handle` key and every import passes it on, so a file
reached from two environments becomes two modules. When a file lies in
one of its handle's site-package directories and that environment
differs from its location config's, `State::get_config` uses a cached
copy of the config with the importer's site-package path, so its imports
resolve to the same modules as the importer's. A file opened on its own
keeps its own config. Bundled stubs never carry an environment, and the
stdlib is still computed once per version and platform.

Co-Authored-By: Claude <noreply@anthropic.com>

Author: ysheikh2

crates/pyrefly_build/src/handle.rs

@@ -9,6 +9,7 @@ use dupe::Dupe;
 use pyrefly_python::module_name::ModuleName;
 use pyrefly_python::module_name::ModuleNameWithKind;
 use pyrefly_python::module_path::ModulePath;
+use pyrefly_python::module_path::ModulePathDetails;
 use pyrefly_python::sys_info::SysInfo;
 
 /// A handle to a Python module, containing its name, path, and system information.
@@ -22,11 +23,7 @@ pub struct Handle {
 impl Handle {
     /// Create a new handle with a guaranteed module name.
     pub fn new(module: ModuleName, path: ModulePath, sys_info: SysInfo) -> Self {
-        Self {
-            module: ModuleNameWithKind::guaranteed(module),
-            path,
-            sys_info,
-        }
+        Self::from_with_module_name_kind(ModuleNameWithKind::guaranteed(module), path, sys_info)
     }
 
     /// Create a new handle from a ModuleNameWithKind.
@@ -35,6 +32,15 @@ impl Handle {
         path: ModulePath,
         sys_info: SysInfo,
     ) -> Self {
+        // Bundled modules are shared by every Python environment, so they never carry one.
+        let sys_info = match path.details() {
+            ModulePathDetails::BundledTypeshed(_)
+            | ModulePathDetails::BundledTypeshedThirdParty(_)
+            | ModulePathDetails::BundledThirdParty(_) => sys_info.without_site_package_path(),
+            ModulePathDetails::FileSystem(_)
+            | ModulePathDetails::Memory(_)
+            | ModulePathDetails::Namespace(_) => sys_info,
+        };
         Self {
             module,
             path,

crates/pyrefly_config/src/config.rs

@@ -1162,6 +1162,7 @@ impl ConfigFile {
 
     pub fn get_sys_info(&self) -> SysInfo {
         SysInfo::new(self.python_version(), self.python_platform().clone())
+            .with_site_package_path(&self.site_package_path().cloned().collect::<Vec<_>>())
     }
 
     pub fn errors(&self, path: &ModulePath) -> Cow<'_, ErrorDisplayConfig> {

crates/pyrefly_python/src/sys_info.rs

@@ -11,6 +11,7 @@ use std::fmt;
 use std::fmt::Display;
 use std::hash::Hash;
 use std::hash::Hasher;
+use std::path::PathBuf;
 use std::str::FromStr;
 
 use dupe::Dupe;
@@ -406,9 +407,9 @@ impl<'de> Deserialize<'de> for PythonPlatform {
 static SYS_INFO_INTERNER: Interner<SysInfoInner> = Interner::new();
 
 /// Information available from the Python library `sys`, namely
-/// `version` and `platform`.
+/// `version` and `platform`, plus the Python environment that imports resolve in.
 /// Interned so that cloning is a trivial pointer copy (no atomic refcount).
-/// There are very few distinct SysInfo values (typically 1 per run), so the
+/// There are very few distinct SysInfo values (typically 1 per Python environment), so the
 /// leaked memory from interning is negligible.
 #[derive(Clone, Dupe, Copy, Debug, PartialEq, Eq, PartialOrd, Ord, Hash)]
 pub struct SysInfo(Intern<SysInfoInner>);
@@ -418,6 +419,7 @@ struct SysInfoInner {
     version: PythonVersion,
     platform: PythonPlatform,
     type_checking: bool,
+    site_package_path: Option<Vec<PathBuf>>,
 }
 
 impl Default for SysInfoInner {
@@ -426,6 +428,7 @@ impl Default for SysInfoInner {
             version: PythonVersion::default(),
             platform: PythonPlatform::default(),
             type_checking: true,
+            site_package_path: None,
         }
     }
 }
@@ -442,6 +445,7 @@ impl SysInfo {
             version,
             platform,
             type_checking: true,
+            site_package_path: None,
         }))
     }
 
@@ -450,6 +454,31 @@ impl SysInfo {
             version,
             platform,
             type_checking: false,
+            site_package_path: None,
+        }))
+    }
+
+    /// Records the directories that third-party imports are resolved from. A handle passes
+    /// its `SysInfo` on to every module it imports, so a file imported from two environments
+    /// becomes two modules. An empty path means the environment is unknown.
+    pub fn with_site_package_path(self, path: &[PathBuf]) -> Self {
+        Self(SYS_INFO_INTERNER.intern(SysInfoInner {
+            site_package_path: (!path.is_empty()).then(|| path.to_vec()),
+            ..(*self.0).clone()
+        }))
+    }
+
+    /// The directories that third-party imports are resolved from, if known.
+    pub fn site_package_path(&self) -> Option<&[PathBuf]> {
+        self.0.site_package_path.as_deref()
+    }
+
+    /// The same `SysInfo` without a Python environment, for anything shared across
+    /// environments, such as the stdlib.
+    pub fn without_site_package_path(self) -> Self {
+        Self(SYS_INFO_INTERNER.intern(SysInfoInner {
+            site_package_path: None,
+            ..(*self.0).clone()
         }))
     }
 

pyrefly/lib/report/pysa/module.rs

@@ -50,8 +50,12 @@ impl ModuleIds {
     pub fn new(handles: &[Handle]) -> ModuleIds {
         let step = StepLogger::start("Building unique module ids", "Built unique module ids");
 
-        // Collect unique SysInfo values from project handles.
-        let sys_infos: HashSet<SysInfo> = handles.iter().map(|handle| *handle.sys_info()).collect();
+        // Collect unique SysInfo values from project handles. Typeshed handles carry no
+        // Python environment, so drop it to avoid duplicate typeshed handles.
+        let sys_infos: HashSet<SysInfo> = handles
+            .iter()
+            .map(|handle| handle.sys_info().without_site_package_path())
+            .collect();
 
         // Build sorted typeshed handles for each SysInfo variant.
         let typeshed = typeshed().expect("Failed to load typeshed");

pyrefly/lib/state/state.rs

@@ -2043,7 +2043,11 @@ impl<'a> Transaction<'a> {
             return self.data.stdlib.first().unwrap().1.dupe();
         }
 
-        self.data.stdlib.get(handle.sys_info()).unwrap().dupe()
+        self.data
+            .stdlib
+            .get(&handle.sys_info().without_site_package_path())
+            .unwrap()
+            .dupe()
     }
 
     /// Compute the `Stdlib` for each requested `SysInfo`.
@@ -2056,7 +2060,10 @@ impl<'a> Transaction<'a> {
     /// Returns `true` if all entries were already cached (no work done).
     fn compute_stdlib(&mut self, handles: &[Handle]) -> bool {
         // Filter out SysInfos that already have a computed stdlib.
-        let sys_infos: SmallSet<SysInfo> = handles.iter().map(|h| h.sys_info().dupe()).collect();
+        let sys_infos: SmallSet<SysInfo> = handles
+            .iter()
+            .map(|h| h.sys_info().without_site_package_path())
+            .collect();
         let missing: SmallSet<SysInfo> = sys_infos
             .into_iter()
             .filter(|k| !self.data.stdlib.contains_key(k))
@@ -2067,13 +2074,14 @@ impl<'a> Transaction<'a> {
         // Use defaults (disabled) for stdlib - depth limiting is for user code
         let thread_state = ThreadState::new(None);
         for k in missing.into_iter_hashed() {
-            // The stdlib is cached per `SysInfo`, so every handle sharing this `SysInfo`
-            // must resolve to the same `typeshed_path`; otherwise the cached stdlib would
-            // depend on which handle happened to be seen first. Enforce that invariant
-            // rather than silently loading the stdlib from an arbitrary handle's typeshed.
+            // The stdlib is cached per `SysInfo` without its Python environment, so every
+            // handle sharing this key must resolve to the same `typeshed_path`; otherwise the
+            // cached stdlib would depend on which handle happened to be seen first. Enforce
+            // that invariant rather than silently loading the stdlib from an arbitrary
+            // handle's typeshed.
             let config = handles
                 .iter()
-                .filter(|h| h.sys_info() == &*k)
+                .filter(|h| h.sys_info().without_site_package_path() == *k)
                 .map(|h| self.data.state.get_config(h))
                 .reduce(|a, b| {
                     assert_eq!(
@@ -2500,6 +2508,7 @@ impl<'a> Transaction<'a> {
         // We clear the global config cache, rather than making a dedicated copy.
         // This is reasonable, because we will cache the result on ModuleData.
         self.data.state.config_finder.clear();
+        self.data.state.environment_configs.lock().clear();
 
         // Wipe the copy of ConfigFile on each module that has changed.
         // If they change, set find to dirty.
@@ -3510,6 +3519,10 @@ pub struct State {
     threads: ThreadPool,
     uniques: UniqueFactory,
     config_finder: ConfigFinder,
+    /// The configs of modules checked in a Python environment other than their own, by
+    /// the config they derive from and the environment. Kept so that a module's config stays
+    /// the same object, which its import resolution cache is keyed by.
+    environment_configs: Mutex<SmallMap<(ArcId<ConfigFile>, SysInfo), ArcId<ConfigFile>>>,
     state: RwLock<StateData>,
     run_count: AtomicUsize,
     committing_transaction_lock: Mutex<()>,
@@ -3545,6 +3558,7 @@ impl State {
             threads: ThreadPool::new(thread_count),
             uniques: UniqueFactory::new(),
             config_finder,
+            environment_configs: Mutex::new(SmallMap::new()),
             state: RwLock::new(StateData::new()),
             run_count: AtomicUsize::new(0),
             committing_transaction_lock: Mutex::new(()),
@@ -3584,8 +3598,37 @@ impl State {
         ) {
             BundledTypeshedStdlib::config()
         } else {
-            self.config_finder
-                .python_file(handle.module_kind(), handle.path())
+            let config = self
+                .config_finder
+                .python_file(handle.module_kind(), handle.path());
+            // A module found through the site-package path of an importer in another Python
+            // environment is checked in the importer's environment, so that its own imports
+            // resolve to the same modules as the importer's.
+            match handle.sys_info().site_package_path() {
+                Some(site_package_path)
+                    if site_package_path
+                        .iter()
+                        .any(|dir| handle.path().as_path().starts_with(dir))
+                        && !config.site_package_path().eq(site_package_path) =>
+                {
+                    self.environment_configs
+                        .lock()
+                        .entry((config.dupe(), *handle.sys_info()))
+                        .or_insert_with(|| {
+                            let mut config = ConfigFile::clone(&config);
+                            config.python_environment.site_package_path =
+                                Some(site_package_path.to_vec());
+                            config
+                                .python_environment
+                                .interpreter_site_package_path
+                                .clear();
+                            config.python_environment.interpreter_editable_path.clear();
+                            ArcId::new(config)
+                        })
+                        .dupe()
+                }
+                _ => config,
+            }
         }
     }