pyrefly 0.25.1__tar.gz → 0.26.1__tar.gz

{pyrefly-0.25.1 → pyrefly-0.26.1}/Cargo.lock

@@ -2029,7 +2029,7 @@ dependencies = [
 
 [[package]]
 name = "pyrefly"
-version = "0.25.1"
+version = "0.26.1"
 dependencies = [
  "anstream",
  "anyhow",
@@ -2063,6 +2063,7 @@ dependencies = [
  "ruff_text_size",
  "serde",
  "serde_json",
+ "serde_repr",
  "starlark_map",
  "static_assertions",
  "tempfile",
@@ -2076,7 +2077,7 @@ dependencies = [
 
 [[package]]
 name = "pyrefly_bundled"
-version = "0.25.1"
+version = "0.26.1"
 dependencies = [
  "anyhow",
  "starlark_map",
@@ -2086,7 +2087,7 @@ dependencies = [
 
 [[package]]
 name = "pyrefly_config"
-version = "0.25.1"
+version = "0.26.1"
 dependencies = [
  "anyhow",
  "clap",
@@ -2119,7 +2120,7 @@ dependencies = [
 
 [[package]]
 name = "pyrefly_derive"
-version = "0.25.1"
+version = "0.26.1"
 dependencies = [
  "proc-macro2",
  "quote",
@@ -2128,7 +2129,7 @@ dependencies = [
 
 [[package]]
 name = "pyrefly_python"
-version = "0.25.1"
+version = "0.26.1"
 dependencies = [
  "anyhow",
  "dupe",
@@ -2150,8 +2151,9 @@ dependencies = [
 
 [[package]]
 name = "pyrefly_types"
-version = "0.25.1"
+version = "0.26.1"
 dependencies = [
+ "compact_str 0.8.0",
  "dupe",
  "itertools 0.14.0",
  "num-bigint",
@@ -2169,13 +2171,14 @@ dependencies = [
 
 [[package]]
 name = "pyrefly_util"
-version = "0.25.1"
+version = "0.26.1"
 dependencies = [
  "anstream",
  "anyhow",
  "append-only-vec",
  "argfile",
  "bstr",
+ "compact_str 0.8.0",
  "const-str",
  "dupe",
  "equivalent",

{pyrefly-0.25.1 → pyrefly-0.26.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pyrefly
-Version: 0.25.1
+Version: 0.26.1
 Classifier: Development Status :: 3 - Alpha
 Classifier: Programming Language :: Python
 Classifier: Programming Language :: Python :: 3
@@ -12,8 +12,6 @@ Classifier: Intended Audience :: Developers
 Classifier: Topic :: Software Development
 Summary: A fast Python type checker written in Rust
 Keywords: typechecker,typechecking
-Author: Meta
-License: MIT
 Requires-Python: >=3.8
 Description-Content-Type: text/markdown; charset=UTF-8; variant=GFM
 Project-URL: homepage, https://pyrefly.org

{pyrefly-0.25.1 → pyrefly-0.26.1}/crates/pyrefly_bundled/Cargo.toml

@@ -2,7 +2,7 @@
 
 [package]
 name = "pyrefly_bundled"
-version = "0.25.1"
+version = "0.26.1"
 authors = ["Meta"]
 edition = "2024"
 repository = "https://github.com/facebook/pyrefly"

{pyrefly-0.25.1 → pyrefly-0.26.1}/crates/pyrefly_config/Cargo.toml

@@ -2,7 +2,7 @@
 
 [package]
 name = "pyrefly_config"
-version = "0.25.1"
+version = "0.26.1"
 authors = ["Meta"]
 edition = "2024"
 repository = "https://github.com/facebook/pyrefly"

{pyrefly-0.25.1 → pyrefly-0.26.1}/crates/pyrefly_config/src/config.rs

@@ -48,9 +48,8 @@ pub struct SubConfig {
 }
 
 impl SubConfig {
-    fn rewrite_with_path_to_config(&mut self, config_root: &Path) -> anyhow::Result<()> {
-        self.matches = self.matches.clone().from_root(config_root)?;
-        Ok(())
+    fn rewrite_with_path_to_config(&mut self, config_root: &Path) {
+        self.matches = self.matches.clone().from_root(config_root);
     }
 }
 
@@ -85,29 +84,43 @@ pub enum ProjectLayout {
     Flat,
     /// Python packages live in a src/ subdirectory
     Src,
+    /// The parent directory of the project root is the import root
+    /// (this is how pandas is set up for some reason)
+    Parent,
 }
 
 impl ProjectLayout {
     pub fn new(project_root: &Path) -> Self {
+        let error = |path: PathBuf, error| {
+            debug!(
+                "Error checking for existence of path {}: {}",
+                path.display(),
+                error
+            );
+            Self::default()
+        };
         let src_subdir = project_root.join("src");
         match src_subdir.try_exists() {
-            Ok(true) => Self::Src,
-            Ok(false) => Self::Flat,
-            Err(e) => {
-                debug!(
-                    "Error checking for existence of path {}: {}",
-                    src_subdir.display(),
-                    e
-                );
-                Self::default()
+            Ok(true) => return Self::Src,
+            Ok(false) => (),
+            Err(e) => return error(src_subdir, e),
+        }
+        for suffix in ["py", "pyi"] {
+            let init_file = project_root.join(format!("__init__.{suffix}"));
+            match init_file.try_exists() {
+                Ok(true) => return Self::Parent,
+                Ok(false) => (),
+                Err(e) => return error(init_file, e),
             }
         }
+        Self::Flat
     }
 
     fn get_import_root(&self, project_root: &Path) -> PathBuf {
         match self {
             Self::Flat => project_root.to_path_buf(),
             Self::Src => project_root.join("src"),
+            Self::Parent => project_root.parent().unwrap_or(project_root).to_path_buf(),
         }
     }
 }
@@ -323,14 +336,13 @@ impl ConfigFile {
         let mut result = Self {
             project_includes: Self::default_project_includes(),
             project_excludes: Self::default_project_excludes(),
-            // Note that rewrite_with_path_to_config() converts "" to the config file's containing directory.
-            import_root: Some(layout.get_import_root(Path::new(""))),
+            import_root: Some(layout.get_import_root(root)),
             ..Default::default()
         };
         // ignore failures rewriting path to config, since we're trying to construct
         // an ephemeral config for the user, and it's not fatal (but things might be
         // a little weird)
-        let _ = result.rewrite_with_path_to_config(root);
+        result.rewrite_with_path_to_config(root);
         result
     }
 
@@ -611,9 +623,9 @@ impl ConfigFile {
     /// We do this as a step separate from `configure()` because CLI args may override some of these
     /// values, but CLI args will always be relative to CWD, whereas config values should be relative
     /// to the config root.
-    fn rewrite_with_path_to_config(&mut self, config_root: &Path) -> anyhow::Result<()> {
-        self.project_includes = self.project_includes.clone().from_root(config_root)?;
-        self.project_excludes = self.project_excludes.clone().from_root(config_root)?;
+    fn rewrite_with_path_to_config(&mut self, config_root: &Path) {
+        self.project_includes = self.project_includes.clone().from_root(config_root);
+        self.project_excludes = self.project_excludes.clone().from_root(config_root);
         self.search_path_from_file
             .iter_mut()
             .for_each(|search_root| {
@@ -637,8 +649,7 @@ impl ConfigFile {
             .map(|s| s.map(|i| i.absolutize_from(config_root)));
         self.sub_configs
             .iter_mut()
-            .try_for_each(|c| c.rewrite_with_path_to_config(config_root))?;
-        Ok(())
+            .for_each(|c| c.rewrite_with_path_to_config(config_root));
     }
 
     pub fn from_file(config_path: &Path) -> (ConfigFile, Vec<ConfigError>) {
@@ -670,10 +681,7 @@ impl ConfigFile {
                 Some(config_root) => {
                     let layout = ProjectLayout::new(config_root);
                     if let Some(mut config) = maybe_config {
-                        let rewrite_error = config.rewrite_with_path_to_config(config_root);
-                        if let Err(error) = rewrite_error {
-                            errors.push(ConfigError::error(error));
-                        }
+                        config.rewrite_with_path_to_config(config_root);
                         config.import_root = Some(layout.get_import_root(config_root));
                         config
                     } else {
@@ -1128,7 +1136,7 @@ mod tests {
         )
         .unwrap();
 
-        config.rewrite_with_path_to_config(&test_path).unwrap();
+        config.rewrite_with_path_to_config(&test_path);
 
         let expected_config = ConfigFile {
             source: ConfigSource::Synthetic,

{pyrefly-0.25.1 → pyrefly-0.26.1}/crates/pyrefly_derive/Cargo.toml

@@ -2,7 +2,7 @@
 
 [package]
 name = "pyrefly_derive"
-version = "0.25.1"
+version = "0.26.1"
 authors = ["Meta"]
 edition = "2024"
 repository = "https://github.com/facebook/pyrefly"

{pyrefly-0.25.1 → pyrefly-0.26.1}/crates/pyrefly_python/Cargo.toml

@@ -2,7 +2,7 @@
 
 [package]
 name = "pyrefly_python"
-version = "0.25.1"
+version = "0.26.1"
 authors = ["Meta"]
 edition = "2024"
 repository = "https://github.com/facebook/pyrefly"

{pyrefly-0.25.1 → pyrefly-0.26.1}/crates/pyrefly_python/src/docstring.rs

@@ -56,6 +56,7 @@ impl Docstring {
         // Remove the shortest amount of whitespace from the beginning of each line
         let min_indent = result
             .lines()
+            .skip(1)
             .flat_map(|line| {
                 let spaces = line.bytes().take_while(|&c| c == b' ').count();
                 if spaces == line.len() {
@@ -69,7 +70,14 @@ impl Docstring {
 
         result
             .lines()
-            .map(|line| &line[min(min_indent, line.len())..])
+            .enumerate()
+            .map(|(i, line)| {
+                if i == 0 {
+                    line
+                } else {
+                    &line[min(min_indent, line.len())..]
+                }
+            })
             .collect::<Vec<_>>()
             .join("\n")
     }
@@ -144,8 +152,8 @@ mod tests {
     #[test]
     fn test_clean_trims_shortest_whitespace() {
         assert_eq!(
-            Docstring::clean("  hello\n    world\n  test").as_str(),
-            "hello\n  world\ntest"
+            Docstring::clean("\n  hello\n    world\n  test").as_str(),
+            "\nhello\n  world\ntest"
         );
     }
 
@@ -153,4 +161,12 @@ mod tests {
     fn test_docstring_panic() {
         Docstring::clean(" F\n\u{85}");
     }
+
+    #[test]
+    fn test_docstring_multiline_starts_at_first() {
+        assert_eq!(
+            Docstring::clean("\"\"\"hello\n  world\n  test\"\"\"").as_str(),
+            "hello\nworld\ntest"
+        );
+    }
 }

{pyrefly-0.25.1 → pyrefly-0.26.1}/crates/pyrefly_types/Cargo.toml

@@ -2,17 +2,18 @@
 
 [package]
 name = "pyrefly_types"
-version = "0.25.1"
+version = "0.26.1"
 authors = ["Meta"]
 edition = "2024"
 repository = "https://github.com/facebook/pyrefly"
 license = "MIT"
 
 [dependencies]
+compact_str = "0.8.0"
 dupe = "0.9.1"
 itertools = "0.14.0"
-num-bigint = { version = "0.4.4", features = ["rand"] }
-num-traits = { version = "0.2.18", default-features = false }
+num-bigint = { version = "0.4.6", features = ["rand"] }
+num-traits = { version = "0.2.19", default-features = false }
 parse-display = "0.8.2"
 pyrefly_derive = { path = "../pyrefly_derive" }
 pyrefly_python = { path = "../pyrefly_python" }

{pyrefly-0.25.1 → pyrefly-0.26.1}/crates/pyrefly_types/src/annotation.rs

@@ -17,6 +17,7 @@ use pyrefly_derive::VisitMut;
 use pyrefly_util::display::intersperse_iter;
 
 use crate::types::AnyStyle;
+use crate::types::Substitution;
 use crate::types::Type;
 
 #[derive(Debug, Clone, Default, VisitMut, TypeEq, PartialEq, Eq)]
@@ -69,6 +70,13 @@ impl Annotation {
     pub fn has_qualifier(&self, qualifier: &Qualifier) -> bool {
         self.qualifiers.iter().any(|q| q == qualifier)
     }
+
+    pub fn substitute(self, substitution: Substitution) -> Self {
+        Self {
+            qualifiers: self.qualifiers,
+            ty: self.ty.map(|ty| substitution.substitute(ty)),
+        }
+    }
 }
 
 #[derive(Debug, Clone, VisitMut, TypeEq, PartialEq, Eq, Display)]

{pyrefly-0.25.1 → pyrefly-0.26.1}/crates/pyrefly_types/src/callable.rs

@@ -15,7 +15,7 @@ use pyrefly_derive::VisitMut;
 use pyrefly_python::dunder;
 use pyrefly_python::module_name::ModuleName;
 use pyrefly_util::display::commas_iter;
-use pyrefly_util::prelude::SliceExt;
+use pyrefly_util::prelude::VecExt;
 use ruff_python_ast::Keyword;
 use ruff_python_ast::name::Name;
 
@@ -46,8 +46,8 @@ impl ParamList {
     }
 
     /// Create a new ParamList from a list of types, as required position-only parameters.
-    pub fn new_types(xs: &[Type]) -> Self {
-        Self(xs.map(|t| Param::PosOnly(None, t.clone(), Required::Required)))
+    pub fn new_types(xs: Vec<Type>) -> Self {
+        Self(xs.into_map(|t| Param::PosOnly(None, t, Required::Required)))
     }
 
     /// Prepend some required position-only parameters.
@@ -96,6 +96,42 @@ impl ParamList {
         Ok(())
     }
 
+    /// Format parameters each parameter on a new line
+    pub fn fmt_with_type_with_newlines<'a, D: Display + 'a>(
+        &'a self,
+        f: &mut fmt::Formatter<'_>,
+        wrap: &'a impl Fn(&'a Type) -> D,
+    ) -> fmt::Result {
+        let mut named_posonly = false;
+        let mut kwonly = false;
+
+        for (i, param) in self.0.iter().enumerate() {
+            if i > 0 {
+                write!(f, ",\n    ")?;
+            }
+
+            if matches!(param, Param::PosOnly(Some(_), _, _)) {
+                named_posonly = true;
+            } else if named_posonly {
+                named_posonly = false;
+                write!(f, "/,\n    ")?;
+            }
+
+            if !kwonly && matches!(param, Param::KwOnly(..)) {
+                kwonly = true;
+                write!(f, "*,\n    ")?;
+            }
+
+            param.fmt_with_type(f, wrap)?;
+        }
+
+        if named_posonly {
+            write!(f, ",\n    /")?;
+        }
+
+        Ok(())
+    }
+
     pub fn items(&self) -> &[Param] {
         &self.0
     }
@@ -200,7 +236,9 @@ pub struct FuncFlags {
     /// A `foo.setter` function, where `foo` is some `@property`-decorated function.
     /// When used to decorate a function, turns the decorated function into a property setter.
     pub is_property_setter_decorator: bool,
-    /// A function decorated with `@foo.setter`, where `foo` is some `@property`-decorated function.
+    /// If None, this is a function decorated with `@foo.setter`, where `foo` is
+    /// a property (i.e. a function decoratoed with `@property`)
+    ///
     /// The stored type is `foo` (the getter).
     pub is_property_setter_with_getter: Option<Type>,
     pub has_enum_member_decoration: bool,
@@ -305,6 +343,26 @@ impl Callable {
         }
     }
 
+    /// Format the function type for use in a hover tooltip. This is similar to `fmt_with_type`, but
+    /// it puts args on new lines if there is more than one argument
+    pub fn fmt_with_type_with_newlines<'a, D: Display + 'a>(
+        &'a self,
+        f: &mut fmt::Formatter<'_>,
+        wrap: &'a impl Fn(&'a Type) -> D,
+    ) -> fmt::Result {
+        match &self.params {
+            Params::List(params) if params.len() > 1 => {
+                // For multiple parameters, put each on a new line with indentation
+                write!(f, "(\n    ")?;
+                params.fmt_with_type_with_newlines(f, wrap)?;
+                write!(f, "\n) -> {}", wrap(&self.ret))
+            }
+            Params::List(..) | Params::ParamSpec(..) | Params::Ellipsis => {
+                self.fmt_with_type(f, wrap)
+            }
+        }
+    }
+
     pub fn list(params: ParamList, ret: Type) -> Self {
         Self {
             params: Params::List(params),
@@ -433,22 +491,33 @@ impl Param {
                 write!(f, "_: {} = {}", wrap(ty), self.fmt_default(default))
             }
             Param::PosOnly(Some(name), ty, Required::Required)
-            | Param::Pos(name, ty, Required::Required) => {
+            | Param::Pos(name, ty, Required::Required)
+            | Param::KwOnly(name, ty, Required::Required) => {
                 write!(f, "{}: {}", name, wrap(ty),)
             }
             Param::PosOnly(Some(name), ty, Required::Optional(default))
-            | Param::Pos(name, ty, Required::Optional(default)) => {
+            | Param::Pos(name, ty, Required::Optional(default))
+            | Param::KwOnly(name, ty, Required::Optional(default)) => {
                 write!(f, "{}: {} = {}", name, wrap(ty), self.fmt_default(default))
             }
             Param::VarArg(Some(name), ty) => write!(f, "*{}: {}", name, wrap(ty)),
             Param::VarArg(None, ty) => write!(f, "*{}", wrap(ty)),
-            Param::KwOnly(name, ty, _required) => write!(f, "{}: {}", name, wrap(ty)),
             Param::Kwargs(Some(name), ty) => write!(f, "**{}: {}", name, wrap(ty)),
             Param::Kwargs(None, ty) => write!(f, "**{}", wrap(ty)),
         }
     }
 
-    pub fn param_to_type(&self) -> &Type {
+    pub fn as_type(&self) -> &Type {
+        match self {
+            Param::PosOnly(_, ty, _)
+            | Param::Pos(_, ty, _)
+            | Param::VarArg(_, ty)
+            | Param::KwOnly(_, ty, _)
+            | Param::Kwargs(_, ty) => ty,
+        }
+    }
+
+    pub fn as_type_mut(&mut self) -> &mut Type {
         match self {
             Param::PosOnly(_, ty, _)
             | Param::Pos(_, ty, _)