pyrefly 0.13.1__tar.gz → 0.14.0__tar.gz

{pyrefly-0.13.1 → pyrefly-0.14.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pyrefly
-Version: 0.13.1
+Version: 0.14.0
 Author: Meta
 License: MIT
 Project-URL: Source Code, https://github.com/facebook/pyrefly

{pyrefly-0.13.1 → pyrefly-0.14.0}/pyrefly/Cargo.lock

@@ -1228,9 +1228,9 @@ dependencies = [
 
 [[package]]
 name = "kqueue"
-version = "1.0.8"
+version = "1.1.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7447f1ca1b7b563588a205fe93dea8df60fd981423a768bc1c0ded35ed147d0c"
+checksum = "8cf0c5a3f977f1cebd92cf05ebb14e1c941c642fb57c9a7d4302455b33ba326f"
 dependencies = [
  "kqueue-sys",
  "libc",
@@ -1754,7 +1754,7 @@ dependencies = [
 
 [[package]]
 name = "pyrefly"
-version = "0.13.1"
+version = "0.14.0"
 dependencies = [
  "anyhow",
  "append-only-vec",

{pyrefly-0.13.1 → pyrefly-0.14.0}/pyrefly/Cargo.toml

@@ -2,7 +2,7 @@
 
 [package]
 name = "pyrefly"
-version = "0.13.1"
+version = "0.14.0"
 authors = ["Meta"]
 edition = "2021"
 repository = "https://github.com/facebook/pyrefly"

{pyrefly-0.13.1 → pyrefly-0.14.0}/pyrefly/bin/main.rs

@@ -34,6 +34,7 @@ use path_absolutize::Absolutize;
 use pyrefly::library::library::library::library;
 use pyrefly::library::library::library::library::ConfigSource;
 use pyrefly::library::library::library::library::ModulePath;
+use pyrefly::library::library::library::library::ProjectLayout;
 use starlark_map::small_map::SmallMap;
 use tracing::debug;
 use tracing::info;
@@ -146,9 +147,12 @@ fn get_globs_and_config_for_project(
         None => {
             let current_dir = std::env::current_dir().context("cannot identify current dir")?;
             let config_finder = config_finder(args.clone());
-            config_finder
-                .directory(&current_dir)
-                .unwrap_or_else(|| ArcId::new(args.override_config(ConfigFile::default())))
+            config_finder.directory(&current_dir).unwrap_or_else(|| {
+                ArcId::new(args.override_config(ConfigFile::default_at_root(
+                    &current_dir,
+                    &ProjectLayout::new(&current_dir),
+                )))
+            })
         }
     };
     match &config.source {
@@ -222,7 +226,7 @@ async fn run_command(command: Command, allow_forget: bool) -> anyhow::Result<Com
             run_check(args, watch, files_to_check, config_finder, allow_forget).await
         }
         Command::BuckCheck(args) => args.run(),
-        Command::Lsp(args) => args.run(Vec::new()),
+        Command::Lsp(args) => args.run(),
         // We intentionally make DumpConfig take the same arguments as Check so that dumping the
         // config is as easy as changing the command name.
         Command::DumpConfig(FullCheckArgs {

{pyrefly-0.13.1 → pyrefly-0.14.0}/pyrefly/lib/alt/attr.rs

@@ -1108,32 +1108,34 @@ impl<'a, Ans: LookupAnswer> AnswersSolver<'a, Ans> {
 
     fn get_module_attr(&self, module: &Module, attr_name: &Name) -> Option<Type> {
         let module_name = ModuleName::from_parts(module.path());
-        match self.get_module_exports(module_name) {
+
+        let module_export_type = match self.get_module_exports(module_name) {
             None => {
                 // We have already errored on `m` when loading the module. No need to emit error again.
                 Some(Type::any_error())
             }
-            Some(exports) => self
-                .get_exported_type(&exports, module_name, attr_name)
-                .or_else(|| {
-                    // `module_name` could also refer to a package, in which case we need to check if
-                    // `module_name.attr_name`:
-                    // - Has been imported directly. Unless `module_name` re-exports `attr_name` from itself
-                    //   (in which can `attr_name` will be included in the exports map), we want to make sure that
-                    //   `module_name.attr_name` is only valid when there's an explicit import statement for either
-                    //   `module_name.attr_name` or its submodules. Just importing `module_name`, for example,
-                    //   shouldn't automatically make the submodule name `module_name.attr_name` accessible.
-                    // - Actually exists as a submodule on the filesystem.
-                    let submodule = module.push_path(attr_name.clone());
-                    let submodule_name = module_name.append(attr_name);
-                    if submodule.is_submodules_imported_directly()
-                        && self.get_module_exports(submodule_name).is_some()
-                    {
-                        Some(submodule.to_type())
-                    } else {
-                        None
-                    }
-                }),
+            Some(exports) => self.get_exported_type(&exports, module_name, attr_name),
+        };
+
+        // `module_name` could refer to a package, in which case we need to check if
+        // `module_name.attr_name`:
+        // - Has been imported directly. We want to make sure that `module_name.attr_name` is only
+        //   valid when there's an explicit import statement for either `module_name.attr_name` or its
+        //   submodules. Just importing `module_name`, for example, shouldn't automatically make the
+        //   submodule name `module_name.attr_name` accessible.
+        // - Actually exists as a submodule on the filesystem.
+        //
+        // This check always takes precedence over the result of the module export lookup, because the import system
+        // would always bind the submodule name `attr_name` to the namespace of `module_name` *after* the module
+        // toplevel of `module_name` has been executed.
+        let submodule = module.push_path(attr_name.clone());
+        let submodule_name = module_name.append(attr_name);
+        if submodule.is_submodules_imported_directly()
+            && self.get_module_exports(submodule_name).is_some()
+        {
+            Some(submodule.to_type())
+        } else {
+            module_export_type
         }
     }
 

{pyrefly-0.13.1 → pyrefly-0.14.0}/pyrefly/lib/alt/operators.rs

@@ -304,7 +304,7 @@ impl<'a, Ans: LookupAnswer> AnswersSolver<'a, Ans> {
                 || ErrorContext::UnaryOp(x.op.as_str().to_owned(), self.for_display(t.clone()));
             match t {
                 Type::Literal(lit) if let Some(ret) = f(lit) => ret,
-                Type::ClassType(_) => {
+                Type::ClassType(_) | Type::SelfType(_) => {
                     self.call_method_or_error(t, method, x.range, &[], &[], errors, Some(&context))
                 }
                 Type::Literal(Lit::Enum(box (cls, ..))) => self.call_method_or_error(

{pyrefly-0.13.1 → pyrefly-0.14.0}/pyrefly/lib/commands/check.rs

@@ -32,7 +32,6 @@ use crate::commands::run::CommandExitStatus;
 use crate::commands::suppress;
 use crate::commands::util::module_from_path;
 use crate::config::config::ConfigFile;
-use crate::config::config::ConfigSource;
 use crate::config::config::validate_path;
 use crate::config::finder::ConfigFinder;
 use crate::error::error::Error;
@@ -210,13 +209,11 @@ impl Handles {
         let unknown = ModuleName::unknown();
         let config = config_finder.python_file(unknown, &module_path);
 
-        let mut search_path = Vec::new();
-        // We want to find the module name for this path, but if we had to create a synthetic
-        // config then we don't really have any idea, and shouldn't use our approximate guess to figure out a name.
-        if config.source != ConfigSource::Synthetic {
-            search_path = config.search_path.clone();
-        }
-        search_path.extend(args_search_path.iter().cloned());
+        let search_path = args_search_path
+            .iter()
+            .cloned()
+            .chain(config.search_path.clone())
+            .collect::<Vec<_>>();
         let module_name = module_from_path(&path, &search_path).unwrap_or(unknown);
 
         self.path_data

{pyrefly-0.13.1 → pyrefly-0.14.0}/pyrefly/lib/commands/config_finder.rs

@@ -14,7 +14,9 @@ use dupe::Dupe;
 use starlark_map::small_map::SmallMap;
 
 use crate::config::config::ConfigFile;
+use crate::config::config::ProjectLayout;
 use crate::config::finder::ConfigFinder;
+use crate::module::bundled::BundledTypeshed;
 use crate::module::module_path::ModulePathDetails;
 use crate::util::arc_id::ArcId;
 use crate::util::lock::Mutex;
@@ -52,8 +54,7 @@ pub fn standard_config_finder(
                 .lock()
                 .entry(path.clone())
                 .or_insert_with(|| {
-                    let mut config = ConfigFile::default();
-                    config.search_path = vec![path.clone()];
+                    let config = ConfigFile::default_at_root(&path, &ProjectLayout::Flat);
                     ArcId::new(configure2(path.parent(), config))
                 })
                 .dupe(),
@@ -62,37 +63,30 @@ pub fn standard_config_finder(
             // path that is still useful for this import by including all of its parents.
             None => {
                 let path = match path.details() {
-                    ModulePathDetails::FileSystem(x) | ModulePathDetails::Memory(x) => x.parent(),
-                    ModulePathDetails::Namespace(x) => Some(x.as_path()),
-                    ModulePathDetails::BundledTypeshed(_) => None,
+                    ModulePathDetails::FileSystem(x) | ModulePathDetails::Memory(x) => {
+                        if let Some(path) = x.parent() {
+                            path
+                        } else {
+                            return empty.dupe();
+                        }
+                    }
+                    ModulePathDetails::Namespace(x) => x.as_path(),
+                    ModulePathDetails::BundledTypeshed(_) => {
+                        return BundledTypeshed::config();
+                    }
                 };
-                match path {
-                    None => empty.dupe(),
-                    Some(path) => cache_parents
-                        .lock()
-                        .entry(path.to_owned())
-                        .or_insert_with(|| {
-                            let mut config = configure2(path.parent(), ConfigFile::default());
-                            // We deliberately set `site_package_path` rather than `search_path` here,
-                            // because otherwise a user with `/sys` on their computer (all of them)
-                            // will override `sys.version` in preference to typeshed.
-                            let additional_site_package_path =
-                                path.ancestors().map(|x| x.to_owned()).collect::<Vec<_>>();
-                            config.python_environment.site_package_path = config
-                                .python_environment
-                                .site_package_path
-                                .map_or(Some(additional_site_package_path.clone()), |path| {
-                                    Some(
-                                        additional_site_package_path
-                                            .into_iter()
-                                            .chain(path)
-                                            .collect(),
-                                    )
-                                });
-                            ArcId::new(config)
-                        })
-                        .dupe(),
-                }
+                cache_parents
+                    .lock()
+                    .entry(path.to_owned())
+                    .or_insert_with(|| {
+                        let mut config = ConfigFile::empty();
+                        // We use `low_priority_search_path` because otherwise a user with `/sys` on their
+                        // computer (all of them) will override `sys.version` in preference to typeshed.
+                        config.low_priority_search_path =
+                            path.ancestors().map(|x| x.to_owned()).collect::<Vec<_>>();
+                        ArcId::new(configure2(path.parent(), config))
+                    })
+                    .dupe()
             }
         }),
     )

{pyrefly-0.13.1 → pyrefly-0.14.0}/pyrefly/lib/commands/lsp.rs

@@ -110,7 +110,6 @@ use crate::commands::config_finder::standard_config_finder;
 use crate::commands::run::CommandExitStatus;
 use crate::commands::util::module_from_path;
 use crate::common::files::PYTHON_FILE_SUFFIXES_TO_WATCH;
-use crate::config::config::ConfigFile;
 use crate::config::environment::PythonEnvironment;
 use crate::config::finder::ConfigFinder;
 use crate::module::module_info::ModuleInfo;
@@ -124,11 +123,9 @@ use crate::state::state::CommittingTransaction;
 use crate::state::state::State;
 use crate::state::state::Transaction;
 use crate::state::state::TransactionData;
-use crate::sys_info::SysInfo;
 use crate::types::lsp::position_to_text_size;
 use crate::types::lsp::source_range_to_range;
 use crate::types::lsp::text_size_to_position;
-use crate::util::arc_id::ArcId;
 use crate::util::args::clap_env;
 use crate::util::globs::Globs;
 use crate::util::lock::Mutex;
@@ -141,10 +138,6 @@ use crate::util::thread_pool::ThreadPool;
 
 #[derive(Debug, Parser, Clone)]
 pub struct Args {
-    #[clap(long = "search-path", env = clap_env("SEARCH_PATH"))]
-    pub(crate) search_path: Vec<PathBuf>,
-    #[clap(long = "site-package-path", env = clap_env("SITE_PACKAGE_PATH"))]
-    pub(crate) site_package_path: Vec<PathBuf>,
     /// Temporary way to obtain the list of all the files belong to a project.
     /// This is necessary to know what files should be considered during find references.
     /// The information should eventually come from configs. TODO(@connernilsen)
@@ -224,10 +217,6 @@ struct Server {
     open_files: Arc<RwLock<HashMap<PathBuf, Arc<String>>>>,
     cancellation_handles: Arc<Mutex<HashMap<RequestId, CancellationHandle>>>,
     workspaces: Arc<Workspaces>,
-    #[expect(dead_code)]
-    search_path: Vec<PathBuf>,
-    #[expect(dead_code)]
-    site_package_path: Vec<PathBuf>,
     outgoing_request_id: Arc<AtomicI32>,
     outgoing_requests: Mutex<HashMap<RequestId, Request>>,
     filewatcher_registered: Arc<AtomicBool>,
@@ -235,12 +224,8 @@ struct Server {
 
 /// Temporary "configuration": this is all that is necessary to run an LSP at a given root.
 /// TODO(connernilsel): replace with real config logic
-#[derive(Debug)]
+#[derive(Debug, Clone)]
 struct Workspace {
-    sys_info: SysInfo,
-    search_path: Vec<PathBuf>,
-    /// The config implied by these settings
-    config_file: ArcId<ConfigFile>,
     #[expect(dead_code)]
     root: PathBuf,
     python_environment: PythonEnvironment,
@@ -253,16 +238,6 @@ impl Workspace {
             root: workspace_root.to_path_buf(),
             python_environment: python_environment.clone(),
             disable_language_services: false,
-            // TODO(connernilsen): delete these
-            sys_info: SysInfo::new(
-                python_environment.python_version.unwrap_or_default(),
-                python_environment
-                    .python_platform
-                    .clone()
-                    .unwrap_or_default(),
-            ),
-            search_path: vec![workspace_root.to_path_buf()],
-            config_file: ArcId::new(ConfigFile::default()),
         }
     }
 
@@ -274,7 +249,18 @@ impl Workspace {
     }
 }
 
+impl Default for Workspace {
+    fn default() -> Self {
+        Self {
+            root: PathBuf::from("/"),
+            python_environment: PythonEnvironment::get_default_interpreter_env(),
+            disable_language_services: Default::default(),
+        }
+    }
+}
+
 struct Workspaces {
+    /// If a workspace is not found, this one is used. It contains every possible file on the system but is lowest priority.
     default: RwLock<Workspace>,
     workspaces: RwLock<SmallMap<PathBuf, Workspace>>,
 }
@@ -287,7 +273,6 @@ impl Workspaces {
         }
     }
 
-    /// TODO(connernilsen): replace with real config logic
     fn get_with<F, R>(&self, uri: PathBuf, f: F) -> R
     where
         F: FnOnce(&Workspace) -> R,
@@ -305,10 +290,12 @@ impl Workspaces {
     fn config_finder(workspaces: &Arc<Workspaces>) -> ConfigFinder {
         let workspaces = workspaces.dupe();
         standard_config_finder(Arc::new(move |dir, mut config| {
-            if let Some(dir) = dir {
+            if let Some(dir) = dir
+                && config.python_interpreter.is_none()
+            {
                 workspaces.get_with(dir.to_owned(), |w| {
                     let site_package_path = config.python_environment.site_package_path.take();
-                    config.python_environment = w.config_file.python_environment.clone();
+                    config.python_environment = w.python_environment.clone();
                     if let Some(new) = site_package_path {
                         let mut workspace = config
                             .python_environment
@@ -318,9 +305,6 @@ impl Workspaces {
                         workspace.extend(new);
                         config.python_environment.site_package_path = Some(workspace);
                     }
-                    config
-                        .search_path
-                        .extend_from_slice(&w.config_file.search_path);
                 })
             };
             config.configure();
@@ -372,8 +356,6 @@ pub fn run_lsp(
             return Err(e.into());
         }
     };
-    let search_path = args.search_path;
-    let site_package_path = args.site_package_path;
     let connection_for_send = connection.dupe();
     let send = move |msg| {
         if connection_for_send.sender.send(msg).is_err() {
@@ -382,12 +364,7 @@ pub fn run_lsp(
             eprintln!("Connection closed.");
         };
     };
-    let server = Server::new(
-        Arc::new(send),
-        initialization_params,
-        search_path,
-        site_package_path,
-    );
+    let server = Server::new(Arc::new(send), initialization_params);
     server.populate_all_project_files(&args.experimental_project_path);
     eprintln!("Reading messages");
     let mut ide_transaction_manager = IDETransactionManager::default();
@@ -410,7 +387,7 @@ pub fn run_lsp(
 }
 
 impl Args {
-    pub fn run(mut self, extra_search_paths: Vec<PathBuf>) -> anyhow::Result<CommandExitStatus> {
+    pub fn run(self) -> anyhow::Result<CommandExitStatus> {
         // Note that  we must have our logging only write out to stderr.
         eprintln!("starting generic LSP server");
 
@@ -418,7 +395,6 @@ impl Args {
         // also be implemented to use sockets or HTTP.
         let (connection, io_threads) = Connection::stdio();
 
-        self.search_path.extend(extra_search_paths);
         run_lsp(
             Arc::new(connection),
             move || io_threads.join().map_err(anyhow::Error::from),
@@ -635,8 +611,6 @@ impl Server {
     fn new(
         send: Arc<dyn Fn(Message) + Send + Sync + 'static>,
         initialize_params: InitializeParams,
-        search_path: Vec<PathBuf>,
-        site_package_path: Vec<PathBuf>,
     ) -> Self {
         let folders = if let Some(capability) = &initialize_params.capabilities.workspace
             && let Some(true) = capability.workspace_folders
@@ -650,14 +624,7 @@ impl Server {
             Vec::new()
         };
 
-        // TODO(kylei): default workspace should have no root
-        let workspaces = Arc::new(Workspaces::new(Workspace::new_with_default_env(
-            &initialize_params
-                .root_uri
-                .clone()
-                .and_then(|x| x.to_file_path().ok())
-                .unwrap_or_else(|| std::env::current_dir().unwrap()),
-        )));
+        let workspaces = Arc::new(Workspaces::new(Workspace::default()));
 
         let config_finder = Workspaces::config_finder(&workspaces);
         let s = Self {
@@ -671,8 +638,6 @@ impl Server {
             open_files: Arc::new(RwLock::new(HashMap::new())),
             cancellation_handles: Arc::new(Mutex::new(HashMap::new())),
             workspaces,
-            search_path,
-            site_package_path,
             outgoing_request_id: Arc::new(AtomicI32::new(1)),
             outgoing_requests: Mutex::new(HashMap::new()),
             filewatcher_registered: Arc::new(AtomicBool::new(false)),
@@ -710,19 +675,13 @@ impl Server {
 
     fn validate_in_memory_for_transaction(
         state: &State,
-        workspaces: &Workspaces,
         open_files: &RwLock<HashMap<PathBuf, Arc<String>>>,
         transaction: &mut Transaction<'_>,
     ) -> Vec<(Handle, Require)> {
         let handles = open_files
             .read()
             .keys()
-            .map(|x| {
-                (
-                    Self::make_open_handle(state, workspaces, x),
-                    Require::Everything,
-                )
-            })
+            .map(|x| (Self::make_open_handle(state, x), Require::Everything))
             .collect::<Vec<_>>();
         transaction.set_memory(
             open_files
@@ -745,12 +704,8 @@ impl Server {
             Ok(transaction) => transaction.as_mut(),
             Err(transaction) => transaction,
         };
-        let handles = Self::validate_in_memory_for_transaction(
-            &self.state,
-            &self.workspaces,
-            &self.open_files,
-            transaction,
-        );
+        let handles =
+            Self::validate_in_memory_for_transaction(&self.state, &self.open_files, transaction);
 
         let publish = |transaction: &Transaction| {
             let mut diags: SmallMap<PathBuf, Vec<Diagnostic>> = SmallMap::new();
@@ -758,7 +713,6 @@ impl Server {
             for x in open_files.keys() {
                 diags.insert(x.as_path().to_owned(), Vec::new());
             }
-            // TODO(connernilsen): replace with real error config from config file
             for e in transaction
                 .get_errors(handles.iter().map(|(handle, _)| handle))
                 .collect_errors()
@@ -839,41 +793,44 @@ impl Server {
     /// entire project to work. This blocking function should be called during server initialization
     /// time if we intend to provide features like find-references, and should be called when config
     /// changes (currently this is a TODO).
-    fn populate_all_project_files(&self, search_paths: &[PathBuf]) {
-        if search_paths.is_empty() {
+    fn populate_all_project_files(&self, workspaces: &[PathBuf]) {
+        if workspaces.is_empty() {
+            eprintln!("Workspaces emtpy, skipping project file population");
             return;
         }
+
+        let config_finder = Workspaces::config_finder(&self.workspaces);
+        let unknown = ModuleName::unknown();
+
         let immediately_handled_events = self.immediately_handled_events.dupe();
         eprintln!(
             "Populating all files in the project path ({:?}).",
-            search_paths
+            workspaces,
         );
         let mut transaction = self
             .state
             .new_committable_transaction(Require::Exports, None);
+
         let mut handles = Vec::new();
-        for search_path in search_paths {
-            let paths = Globs::new_with_root(search_path, vec![".".to_owned()])
+        for workspace in workspaces {
+            // TODO(connernilsen): would love to use the workspace's config, and not require the workspaces arg
+            // (use self.workspaces.workspaces instead), but we get a deadlock when we do :(
+            let paths = Globs::new_with_root(workspace, vec![".".to_owned()])
                 .files()
                 .unwrap_or_default();
+
             for path in paths {
-                let module_name =
-                    module_from_path(&path, search_paths).unwrap_or_else(ModuleName::unknown);
-                // TODO(connernilsen): temp to keep tests working
-                let env = PythonEnvironment::get_default_interpreter_env();
+                let module_path = ModulePath::filesystem(path.clone());
+                let path_config = config_finder.python_file(unknown, &module_path);
+                let module_name = module_from_path(&path, &path_config.search_path)
+                    .unwrap_or_else(ModuleName::unknown);
                 handles.push((
-                    Handle::new(
-                        module_name,
-                        ModulePath::filesystem(path),
-                        SysInfo::new(
-                            env.python_version.unwrap_or_default(),
-                            env.python_platform.unwrap_or_default(),
-                        ),
-                    ),
+                    Handle::new(module_name, module_path, path_config.get_sys_info()),
                     Require::Exports,
                 ));
             }
         }
+
         eprintln!("Prepare to check {} files.", handles.len());
         transaction.as_mut().run(&handles);
         self.state.commit_transaction(transaction);
@@ -972,22 +929,18 @@ impl Server {
         self.request_settings_for_all_workspaces();
     }
 
-    fn module_name(state: &State, workspace: &Workspace, path: &ModulePath) -> ModuleName {
+    fn handle_from_module_path(state: &State, path: ModulePath) -> Handle {
         let unknown = ModuleName::unknown();
-        let config = state.config_finder().python_file(unknown, path);
-        let mut search_path = config.search_path.clone();
-        search_path.extend_from_slice(&workspace.search_path);
-        to_real_path(path)
-            .and_then(|path| module_from_path(path, &search_path))
-            .unwrap_or(unknown)
+        let config = state.config_finder().python_file(unknown, &path);
+        let module_name = to_real_path(&path)
+            .and_then(|path| module_from_path(path, &config.search_path))
+            .unwrap_or(unknown);
+        Handle::new(module_name, path, config.get_sys_info())
     }
 
-    fn make_open_handle(state: &State, workspaces: &Workspaces, path: &Path) -> Handle {
-        workspaces.get_with(path.to_owned(), |workspace| {
-            let path = ModulePath::memory(path.to_owned());
-            let name = Self::module_name(state, workspace, &path);
-            Handle::new(name, path, workspace.sys_info.dupe())
-        })
+    fn make_open_handle(state: &State, path: &Path) -> Handle {
+        let path = ModulePath::memory(path.to_owned());
+        Self::handle_from_module_path(state, path)
     }
 
     /// Create a handle. Return None if the workspace has language services disabled (and thus you shouldn't do anything).
@@ -1002,8 +955,7 @@ impl Server {
                 } else {
                     ModulePath::filesystem(path)
                 };
-                let name = Self::module_name(&self.state, workspace, &module_path);
-                Some(Handle::new(name, module_path, workspace.sys_info.dupe()))
+                Some(Self::handle_from_module_path(&self.state, module_path))
             }
         })
     }
@@ -1108,7 +1060,6 @@ impl Server {
         };
         ide_transaction_manager.save(transaction);
         let state = self.state.dupe();
-        let workspaces = self.workspaces.dupe();
         let open_files = self.open_files.dupe();
         let cancellation_handles = self.cancellation_handles.dupe();
         let send = self.send.dupe();
@@ -1117,12 +1068,7 @@ impl Server {
             cancellation_handles
                 .lock()
                 .insert(request_id.clone(), transaction.get_cancellation_handle());
-            Self::validate_in_memory_for_transaction(
-                &state,
-                &workspaces,
-                &open_files,
-                transaction.as_mut(),
-            );
+            Self::validate_in_memory_for_transaction(&state, &open_files, transaction.as_mut());
             match transaction.find_global_references_from_definition(
                 handle.sys_info(),
                 definition_kind,