pyrefly 0.14.1__tar.gz → 0.15.0__tar.gz

{pyrefly-0.14.1 → pyrefly-0.15.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pyrefly
-Version: 0.14.1
+Version: 0.15.0
 Classifier: Development Status :: 3 - Alpha
 Classifier: Programming Language :: Python
 Classifier: Programming Language :: Python :: 3

{pyrefly-0.14.1 → pyrefly-0.15.0}/pyrefly/Cargo.lock

@@ -325,9 +325,9 @@ dependencies = [
 
 [[package]]
 name = "clap"
-version = "4.5.37"
+version = "4.5.38"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "eccb054f56cbd38340b380d4a8e69ef1f02f1af43db2f0cc817a4774d80ae071"
+checksum = "ed93b9805f8ba930df42c2590f05453d5ec36cbb85d018868a5b24d31f6ac000"
 dependencies = [
  "clap_builder",
  "clap_derive",
@@ -335,9 +335,9 @@ dependencies = [
 
 [[package]]
 name = "clap_builder"
-version = "4.5.37"
+version = "4.5.38"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "efd9466fac8543255d3b1fcad4762c5e116ffe808c8a3043d4263cd4fd4862a2"
+checksum = "379026ff283facf611b0ea629334361c4211d1b12ee01024eec1591133b04120"
 dependencies = [
  "anstream",
  "anstyle",
@@ -1740,7 +1740,7 @@ dependencies = [
 
 [[package]]
 name = "pyrefly"
-version = "0.14.1"
+version = "0.15.0"
 dependencies = [
  "anstream",
  "anyhow",
@@ -2376,9 +2376,9 @@ dependencies = [
 
 [[package]]
 name = "tempfile"
-version = "3.19.1"
+version = "3.20.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7437ac7763b9b123ccf33c338a5cc1bac6f69b45a136c19bdd8a65e3916435bf"
+checksum = "e8a64e3985349f2441a1a9ef0b853f869006c3855f2cda6862a94d26ebb9d6a1"
 dependencies = [
  "fastrand",
  "getrandom 0.3.3",

{pyrefly-0.14.1 → pyrefly-0.15.0}/pyrefly/Cargo.toml

@@ -2,7 +2,7 @@
 
 [package]
 name = "pyrefly"
-version = "0.14.1"
+version = "0.15.0"
 authors = ["Meta"]
 edition = "2021"
 repository = "https://github.com/facebook/pyrefly"
@@ -62,7 +62,7 @@ static_assertions = "1.1.0"
 static_interner = "0.1.1"
 tar = "0.4.44"
 thiserror = "2"
-tokio = { version = "1.44.2", features = ["macros", "rt"] }
+tokio = { version = "1.45.0", features = ["macros", "rt"] }
 toml = "0.8.19"
 tracing = { version = "0.1.41", features = ["attributes", "valuable"] }
 tracing-subscriber = { version = "0.3.18", features = ["chrono", "env-filter", "json", "local-time", "parking_lot", "registry"] }

{pyrefly-0.14.1 → pyrefly-0.15.0}/pyrefly/bin/main.rs

@@ -186,6 +186,12 @@ fn get_globs_and_config_for_project(
         ConfigSource::File(path) => {
             info!("Checking project configured at `{}`", path.display());
         }
+        ConfigSource::Marker(path) => {
+            info!(
+                "Found `{}` marking project root, checking root directory with default configuration",
+                path.display(),
+            );
+        }
         ConfigSource::Synthetic => {
             info!("Checking current directory with default configuration");
         }
@@ -300,8 +306,14 @@ async fn run_command(command: Command, allow_forget: bool) -> anyhow::Result<Com
                     ConfigSource::Synthetic => {
                         println!("Default configuration");
                     }
+                    ConfigSource::Marker(path) => {
+                        println!(
+                            "Default configuration for project root marked by `{}`",
+                            path.display()
+                        );
+                    }
                     ConfigSource::File(path) => {
-                        println!("Configuration at {path:?}");
+                        println!("Configuration at `{}`", path.display());
                     }
                 }
                 println!("  Covered files:");
@@ -313,9 +325,11 @@ async fn run_command(command: Command, allow_forget: bool) -> anyhow::Result<Com
                         break;
                     }
                 }
-                println!("  Search path: {:?}", config.search_path);
-                println!("  Fallback search path: {:?}", config.fallback_search_path);
-                println!("  Site package path: {:?}", config.site_package_path());
+                for path_part in config.structured_import_lookup_path() {
+                    if !path_part.is_empty() {
+                        println!("  {path_part}");
+                    }
+                }
             }
             Ok(CommandExitStatus::Success)
         }

{pyrefly-0.14.1 → pyrefly-0.15.0}/pyrefly/lib/alt/class/class_field.rs

@@ -10,6 +10,7 @@ use std::fmt::Display;
 use std::sync::Arc;
 
 use dupe::Dupe;
+use itertools::Itertools;
 use pyrefly_derive::TypeEq;
 use pyrefly_derive::VisitMut;
 use ruff_python_ast::Arguments;
@@ -538,7 +539,7 @@ impl<'a, Ans: LookupAnswer> AnswersSolver<'a, Ans> {
         // then we can avoid a bunch of work with checking for override errors.
         let mut name_might_exist_in_inherited = true;
 
-        let value_ty = match value {
+        let (value_ty, inherited_annot) = match value {
             ExprOrBinding::Expr(e) => {
                 let inherited_annot = if annotation.is_some() {
                     None
@@ -549,7 +550,7 @@ impl<'a, Ans: LookupAnswer> AnswersSolver<'a, Ans> {
                     }
                     annotation
                 };
-                let mut ty = if let Some(annot) = inherited_annot {
+                let mut ty = if let Some(annot) = &inherited_annot {
                     let ctx: &dyn Fn() -> TypeCheckContext =
                         &|| TypeCheckContext::of_kind(TypeCheckKind::Attribute(name.clone()));
                     let hint = Some((annot.get_type(), ctx));
@@ -558,11 +559,12 @@ impl<'a, Ans: LookupAnswer> AnswersSolver<'a, Ans> {
                     self.expr_infer(e, errors)
                 };
                 self.expand_type_mut(&mut ty);
-                ty
-            }
-            ExprOrBinding::Binding(b) => {
-                Arc::unwrap_or_clone(self.solve_binding(b, errors)).into_ty()
+                (ty, inherited_annot)
             }
+            ExprOrBinding::Binding(b) => (
+                Arc::unwrap_or_clone(self.solve_binding(b, errors)).into_ty(),
+                None,
+            ),
         };
         let metadata = self.get_metadata_for_class(class);
         let magically_initialized = {
@@ -631,16 +633,20 @@ impl<'a, Ans: LookupAnswer> AnswersSolver<'a, Ans> {
         // Determine whether this is an explicit `@override`.
         let is_override = value_ty.is_override();
 
+        let explicit_or_inherited_annot = annotation.or(inherited_annot.as_ref());
+
         // Promote literals. The check on `annotation` is an optimization, it does not (currently) affect semantics.
         // TODO(stroxler): if we see a read-only `Qualifier` like `Final`, it is sound to preserve literals.
-        let value_ty = if annotation.is_none_or(|a| a.ty.is_none()) && value_ty.is_literal() {
+        let value_ty = if explicit_or_inherited_annot.is_none_or(|a| a.ty.is_none())
+            && value_ty.is_literal()
+        {
             value_ty.clone().promote_literals(self.stdlib)
         } else {
             value_ty.clone()
         };
 
         // Types provided in annotations shadow inferred types
-        let ty = if let Some(ann) = annotation {
+        let ty = if let Some(ann) = explicit_or_inherited_annot {
             match &ann.ty {
                 Some(ty) => ty.clone(),
                 None => value_ty.clone(),
@@ -669,6 +675,9 @@ impl<'a, Ans: LookupAnswer> AnswersSolver<'a, Ans> {
         // TODO(stroxler, yangdanny): We currently operate on promoted types, which means we do not infer `Literal[...]`
         // types for the `.value` / `._value_` attributes of literals. This is permitted in the spec although not optimal
         // for most cases; we are handling it this way in part because generic enum behavior is not yet well-specified.
+        //
+        // We currently skip the check for `_value_` if the class defines `__new__`, since that can
+        // change the value of the enum member. https://docs.python.org/3/howto/enum.html#when-to-use-new-vs-init
         let ty = if let Some(enum_) = metadata.enum_metadata()
             && self.is_valid_enum_member(name, &ty, &initialization)
         {
@@ -680,6 +689,7 @@ impl<'a, Ans: LookupAnswer> AnswersSolver<'a, Ans> {
             }
             if enum_.has_value
                 && let Some(enum_value_ty) = self.type_of_enum_value(enum_)
+                && !class.fields().contains(&dunder::NEW)
                 && !self.matches_enum_value_annotation(&ty, &enum_value_ty)
             {
                 self.error(

{pyrefly-0.14.1 → pyrefly-0.15.0}/pyrefly/lib/alt/function.rs

@@ -306,12 +306,7 @@ impl<'a, Ans: LookupAnswer> AnswersSolver<'a, Ans> {
             let ty = match self.bindings().get_function_param(&x.name) {
                 Either::Left(idx) => {
                     let annot = self.get_idx(idx);
-                    let ty = annot.annotation.get_type().clone();
-                    if annot.annotation.is_unpacked() {
-                        Type::Unpack(Box::new(ty))
-                    } else {
-                        ty
-                    }
+                    annot.annotation.get_type().clone()
                 }
                 Either::Right(var) => self.solver().force_var(var),
             };

{pyrefly-0.14.1 → pyrefly-0.15.0}/pyrefly/lib/alt/solve.rs

@@ -295,26 +295,11 @@ impl<'a, Ans: LookupAnswer> AnswersSolver<'a, Ans> {
                     );
                     None
                 }
-                Some(Qualifier::Unpack)
+                Some(Qualifier::TypeAlias)
                     if !matches!(
                         type_form_context,
-                        TypeFormContext::ParameterArgsAnnotation
-                            | TypeFormContext::ParameterKwargsAnnotation,
+                        TypeFormContext::VarAnnotation(_) | TypeFormContext::ClassVarAnnotation
                     ) =>
-                {
-                    self.error(
-                        errors,
-                        x.range(),
-                        ErrorKind::InvalidAnnotation,
-                        None,
-                        "Unpack is not allowed in this context.".to_owned(),
-                    );
-                    // We return the qualifier so that it's consumed and we don't emit a
-                    // duplicate error in the fallback logic
-                    qualifier
-                }
-                Some(Qualifier::TypeAlias)
-                    if !matches!(type_form_context, TypeFormContext::VarAnnotation(_)) =>
                 {
                     self.error(
                         errors,

{pyrefly-0.14.1 → pyrefly-0.15.0}/pyrefly/lib/binding/binding.rs

@@ -1029,7 +1029,7 @@ impl AnnotationWithTarget {
             AnnotationTarget::ArgsParam(_) => {
                 if let Type::Unpack(box unpacked) = annotation_ty {
                     Some(unpacked.clone())
-                } else if self.annotation.is_unpacked() || matches!(annotation_ty, Type::Args(_)) {
+                } else if matches!(annotation_ty, Type::Args(_) | Type::Unpack(_)) {
                     Some(annotation_ty.clone())
                 } else {
                     Some(Type::Tuple(Tuple::Unbounded(Box::new(
@@ -1040,8 +1040,7 @@ impl AnnotationWithTarget {
             AnnotationTarget::KwargsParam(_) => {
                 if let Type::Unpack(box unpacked) = annotation_ty {
                     Some(unpacked.clone())
-                } else if self.annotation.is_unpacked() || matches!(annotation_ty, Type::Kwargs(_))
-                {
+                } else if matches!(annotation_ty, Type::Kwargs(_) | Type::Unpack(_)) {
                     Some(annotation_ty.clone())
                 } else {
                     Some(

{pyrefly-0.14.1 → pyrefly-0.15.0}/pyrefly/lib/binding/expr.rs

@@ -497,8 +497,12 @@ impl<'a> BindingsBuilder<'a> {
                 range: _,
                 func,
                 arguments: _,
-            }) if self.as_special_export(func) == Some(SpecialExport::Exit) => {
-                // Control flow doesn't proceed after sys.exit()
+            }) if matches!(
+                self.as_special_export(func),
+                Some(SpecialExport::Exit | SpecialExport::Quit | SpecialExport::OsExit)
+            ) =>
+            {
+                // Control flow doesn't proceed after sys.exit(), exit(), quit(), or os._exit().
                 self.scopes.current_mut().flow.no_next = true;
                 false
             }

{pyrefly-0.14.1 → pyrefly-0.15.0}/pyrefly/lib/commands/check.rs

@@ -11,7 +11,6 @@ use std::fmt::Display;
 use std::fs::File;
 use std::io::BufWriter;
 use std::io::Write;
-use std::mem;
 use std::path::Path;
 use std::path::PathBuf;
 use std::time::Duration;
@@ -38,6 +37,7 @@ use crate::commands::suppress;
 use crate::commands::util::module_from_path;
 use crate::config::config::ConfigFile;
 use crate::config::config::validate_path;
+use crate::config::environment::environment::SitePackagePathSource;
 use crate::config::finder::ConfigFinder;
 use crate::error::error::Error;
 use crate::error::error::print_error_counts;
@@ -248,12 +248,8 @@ impl Handles {
         let unknown = ModuleName::unknown();
         let config = config_finder.python_file(unknown, &module_path);
 
-        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);
+        let search_path = args_search_path.iter().chain(config.search_path());
+        let module_name = module_from_path(&path, search_path).unwrap_or(unknown);
 
         self.path_data
             .entry(path)
@@ -501,11 +497,11 @@ impl Args {
             config.python_environment.python_version = Some(*x);
         }
         if let Some(x) = &self.search_path {
-            let old = mem::take(&mut config.search_path);
-            config.search_path = x.iter().cloned().chain(old).collect();
+            config.search_path_from_args = x.clone();
         }
         if let Some(x) = &self.site_package_path {
             config.python_environment.site_package_path = Some(x.clone());
+            config.python_environment.site_package_path_source = SitePackagePathSource::CommandLine;
         }
         if let Some(x) = &self.python_interpreter {
             config.python_interpreter = Some(x.clone());

{pyrefly-0.14.1 → pyrefly-0.15.0}/pyrefly/lib/commands/config_finder.rs

@@ -200,7 +200,10 @@ mod tests {
             config_file.source,
             ConfigSource::File(root.join("with_config/pyrefly.toml"))
         );
-        assert_eq!(config_file.search_path, vec![root.join("with_config")]);
+        assert_eq!(
+            config_file.search_path().cloned().collect::<Vec<_>>(),
+            vec![root.join("with_config")]
+        );
         assert_eq!(config_file.fallback_search_path, Vec::<PathBuf>::new());
 
         // we should get a synthetic config with a search path = project_root/..
@@ -210,7 +213,10 @@ mod tests {
             ModulePath::filesystem(root.join("no_config/foo/bar.py")),
         );
         assert_eq!(config_file.source, ConfigSource::Synthetic);
-        assert_eq!(config_file.search_path, vec![root.join("no_config")]);
+        assert_eq!(
+            config_file.search_path().cloned().collect::<Vec<_>>(),
+            vec![root.join("no_config")]
+        );
         assert_eq!(config_file.fallback_search_path, Vec::<PathBuf>::new());
 
         // check invalid module path parent
@@ -241,7 +247,7 @@ mod tests {
             ModulePath::namespace(root.join("no_config/foo")),
         );
         assert_eq!(config_file.source, ConfigSource::Synthetic);
-        assert_eq!(config_file.search_path, Vec::<PathBuf>::new());
+        assert_eq!(config_file.search_path_from_file, Vec::<PathBuf>::new());
         assert_eq!(
             config_file.fallback_search_path,
             [root.join("no_config/foo"), root.join("no_config")]
@@ -257,7 +263,7 @@ mod tests {
             ModulePath::filesystem(root.join("no_config/foo/bar.py")),
         );
         assert_eq!(config_file.source, ConfigSource::Synthetic);
-        assert_eq!(config_file.search_path, Vec::<PathBuf>::new());
+        assert_eq!(config_file.search_path_from_file, Vec::<PathBuf>::new());
         assert_eq!(
             config_file.fallback_search_path,
             [root.join("no_config/foo"), root.join("no_config")]

{pyrefly-0.14.1 → pyrefly-0.15.0}/pyrefly/lib/commands/lsp.rs

@@ -221,8 +221,39 @@ enum ServerEvent {
     LspRequest(Request),
 }
 
+#[derive(Clone, Dupe)]
+struct ServerConnection(Arc<Connection>);
+
+impl ServerConnection {
+    fn send(&self, msg: Message) {
+        if self.0.sender.send(msg).is_err() {
+            // On error, we know the channel is closed.
+            // https://docs.rs/crossbeam/latest/crossbeam/channel/struct.Sender.html#method.send
+            eprintln!("Connection closed.");
+        };
+    }
+
+    fn publish_diagnostics_for_uri(&self, uri: Url, diags: Vec<Diagnostic>, version: Option<i32>) {
+        self.send(Message::Notification(
+            new_notification::<PublishDiagnostics>(PublishDiagnosticsParams::new(
+                uri, diags, version,
+            )),
+        ));
+    }
+
+    fn publish_diagnostics(&self, diags: SmallMap<PathBuf, Vec<Diagnostic>>) {
+        for (path, diags) in diags {
+            let path = std::fs::canonicalize(&path).unwrap_or(path);
+            match Url::from_file_path(&path) {
+                Ok(uri) => self.publish_diagnostics_for_uri(uri, diags, None),
+                Err(_) => eprint!("Unable to convert path to uri: {path:?}"),
+            }
+        }
+    }
+}
+
 struct Server {
-    send: Arc<dyn Fn(Message) + Send + Sync + 'static>,
+    connection: ServerConnection,
     /// A thread pool of size one for heavy read operations on the State
     async_state_read_threads: ThreadPool,
     priority_events_sender: Arc<Sender<ServerEvent>>,
@@ -445,14 +476,6 @@ pub fn run_lsp(
             return Err(e.into());
         }
     };
-    let connection_for_send = connection.dupe();
-    let send = move |msg| {
-        if connection_for_send.sender.send(msg).is_err() {
-            // On error, we know the channel is closed.
-            // https://docs.rs/crossbeam/latest/crossbeam/channel/struct.Sender.html#method.send
-            eprintln!("Connection closed.");
-        };
-    };
     eprintln!("Reading messages");
     let connection_for_dispatcher = connection.dupe();
     let (queued_events_sender, queued_events_receiver) = crossbeam_channel::unbounded();
@@ -464,7 +487,7 @@ pub fn run_lsp(
     let priority_receiver_index = event_receiver_selector.recv(&priority_events_receiver);
     let queued_events_receiver_index = event_receiver_selector.recv(&queued_events_receiver);
     let server = Server::new(
-        Arc::new(send),
+        connection,
         priority_events_sender.dupe(),
         initialization_params,
     );
@@ -491,6 +514,8 @@ pub fn run_lsp(
             break;
         }
     }
+    eprintln!("waiting for connection to close");
+    drop(server); // close connection
     wait_on_connection()?;
 
     // Shut down gracefully.
@@ -559,30 +584,6 @@ fn module_info_to_uri_with_document_content_provider(module_info: &ModuleInfo) -
     }
 }
 
-fn publish_diagnostics_for_uri(
-    send: &Arc<dyn Fn(Message) + Send + Sync + 'static>,
-    uri: Url,
-    diags: Vec<Diagnostic>,
-    version: Option<i32>,
-) {
-    send(Message::Notification(
-        new_notification::<PublishDiagnostics>(PublishDiagnosticsParams::new(uri, diags, version)),
-    ));
-}
-
-fn publish_diagnostics(
-    send: Arc<dyn Fn(Message) + Send + Sync + 'static>,
-    diags: SmallMap<PathBuf, Vec<Diagnostic>>,
-) {
-    for (path, diags) in diags {
-        let path = std::fs::canonicalize(&path).unwrap_or(path);
-        match Url::from_file_path(&path) {
-            Ok(uri) => publish_diagnostics_for_uri(&send, uri, diags, None),
-            Err(_) => eprint!("Unable to convert path to uri: {path:?}"),
-        }
-    }
-}
-
 impl Server {
     const FILEWATCHER_ID: &str = "FILEWATCHER";
 
@@ -709,7 +710,7 @@ impl Server {
     }
 
     fn new(
-        send: Arc<dyn Fn(Message) + Send + Sync + 'static>,
+        connection: Arc<Connection>,
         priority_events_sender: Arc<Sender<ServerEvent>>,
         initialize_params: InitializeParams,
     ) -> Self {
@@ -729,7 +730,7 @@ impl Server {
 
         let config_finder = Workspaces::config_finder(&workspaces);
         let s = Self {
-            send,
+            connection: ServerConnection(connection),
             async_state_read_threads: ThreadPool::with_thread_count(ThreadCount::NumThreads(
                 NonZero::new(1).unwrap(),
             )),
@@ -749,7 +750,7 @@ impl Server {
     }
 
     fn send_response(&self, x: Response) {
-        (self.send)(Message::Response(x))
+        self.connection.send(Message::Response(x))
     }
 
     fn send_request<T>(&self, params: T::Params)
@@ -762,18 +763,10 @@ impl Server {
             method: T::METHOD.to_owned(),
             params: serde_json::to_value(params).unwrap(),
         };
-        (self.send)(Message::Request(request.clone()));
+        self.connection.send(Message::Request(request.clone()));
         self.outgoing_requests.lock().insert(id, request);
     }
 
-    fn publish_diagnostics_for_uri(&self, uri: Url, diags: Vec<Diagnostic>, version: Option<i32>) {
-        publish_diagnostics_for_uri(&self.send, uri, diags, version);
-    }
-
-    fn publish_diagnostics(&self, diags: SmallMap<PathBuf, Vec<Diagnostic>>) {
-        publish_diagnostics(self.send.dupe(), diags);
-    }
-
     fn validate_in_memory_for_transaction(
         state: &State,
         open_files: &RwLock<HashMap<PathBuf, Arc<String>>>,
@@ -834,7 +827,7 @@ impl Server {
                     }
                 }
             }
-            self.publish_diagnostics(diags);
+            self.connection.publish_diagnostics(diags);
         };
 
         match possibly_committable_transaction {
@@ -921,7 +914,7 @@ impl Server {
             for path in paths {
                 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)
+                let module_name = module_from_path(&path, path_config.search_path())
                     .unwrap_or_else(ModuleName::unknown);
                 handles.push((
                     Handle::new(module_name, module_path, path_config.get_sys_info()),
@@ -1012,7 +1005,8 @@ impl Server {
     fn did_close(&self, params: DidCloseTextDocumentParams) -> anyhow::Result<()> {
         let uri = params.text_document.uri.to_file_path().unwrap();
         self.open_files.write().remove(&uri);
-        self.publish_diagnostics_for_uri(params.text_document.uri, Vec::new(), None);
+        self.connection
+            .publish_diagnostics_for_uri(params.text_document.uri, Vec::new(), None);
         Ok(())
     }
 
@@ -1060,7 +1054,7 @@ impl Server {
         let unknown = ModuleName::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))
+            .and_then(|path| module_from_path(path, config.search_path()))
             .unwrap_or(unknown);
         Handle::new(module_name, path, config.get_sys_info())
     }
@@ -1189,7 +1183,8 @@ impl Server {
         let state = self.state.dupe();
         let open_files = self.open_files.dupe();
         let cancellation_handles = self.cancellation_handles.dupe();
-        let send = self.send.dupe();
+
+        let connection = self.connection.dupe();
         self.async_state_read_threads.async_spawn(move || {
             let mut transaction = state.cancellable_transaction();
             cancellation_handles
@@ -1213,7 +1208,7 @@ impl Server {
                             }
                         };
                     }
-                    send(Message::Response(new_response(
+                    connection.send(Message::Response(new_response(
                         request_id,
                         Ok(Some(locations)),
                     )))
@@ -1221,7 +1216,7 @@ impl Server {
                 Err(Cancelled) => {
                     let message = format!("Find reference request {} is canceled", request_id);
                     eprintln!("{message}");
-                    send(Message::Response(Response::new_err(
+                    connection.send(Message::Response(Response::new_err(
                         request_id,
                         ErrorCode::RequestCanceled as i32,
                         message,

{pyrefly-0.14.1 → pyrefly-0.15.0}/pyrefly/lib/commands/util.rs

@@ -13,7 +13,10 @@ use crate::dunder;
 use crate::module::module_name::ModuleName;
 
 /// If the module is on the search path, return its name from that path. Otherwise, return None.
-pub fn module_from_path(path: &Path, includes: &[PathBuf]) -> Option<ModuleName> {
+pub fn module_from_path<'a>(
+    path: &Path,
+    includes: impl Iterator<Item = &'a PathBuf>,
+) -> Option<ModuleName> {
     // Return a module name, and a boolean as to whether it is any good.
     fn path_to_module(mut path: &Path) -> Option<ModuleName> {
         if path.file_stem() == Some(dunder::INIT.as_str().as_ref()) {
@@ -51,26 +54,29 @@ mod tests {
 
     #[test]
     fn test_module_from_path() {
-        let includes = vec![PathBuf::from("/foo/bar")];
+        let includes = [PathBuf::from("/foo/bar")];
         assert_eq!(
-            module_from_path(Path::new("/foo/bar/baz.py"), &includes),
+            module_from_path(Path::new("/foo/bar/baz.py"), includes.iter()),
             Some(ModuleName::from_str("baz"))
         );
         assert_eq!(
-            module_from_path(Path::new("/foo/bar/baz/qux.pyi"), &includes),
+            module_from_path(Path::new("/foo/bar/baz/qux.pyi"), includes.iter()),
             Some(ModuleName::from_str("baz.qux"))
         );
         assert_eq!(
-            module_from_path(Path::new("/foo/bar/baz/test/magic.py"), &includes),
+            module_from_path(Path::new("/foo/bar/baz/test/magic.py"), includes.iter()),
             Some(ModuleName::from_str("baz.test.magic"))
         );
         assert_eq!(
-            module_from_path(Path::new("/foo/bar/baz/__init__.pyi"), &includes),
+            module_from_path(Path::new("/foo/bar/baz/__init__.pyi"), includes.iter()),
             Some(ModuleName::from_str("baz"))
         );
-        assert_eq!(module_from_path(Path::new("/test.py"), &includes), None);
         assert_eq!(
-            module_from_path(Path::new("/not_foo/test.py"), &includes),
+            module_from_path(Path::new("/test.py"), includes.iter()),
+            None
+        );
+        assert_eq!(
+            module_from_path(Path::new("/not_foo/test.py"), includes.iter()),
             None
         );
     }