pyrefly 0.24.0__tar.gz → 0.24.1__tar.gz

{pyrefly-0.24.0 → pyrefly-0.24.1}/Cargo.lock

@@ -1991,7 +1991,7 @@ dependencies = [
 
 [[package]]
 name = "pyrefly"
-version = "0.24.0"
+version = "0.24.1"
 dependencies = [
  "anstream",
  "anyhow",
@@ -2037,7 +2037,7 @@ dependencies = [
  "tikv-jemallocator",
  "tokio",
  "toml",
- "toml_edit 0.23.1",
+ "toml_edit",
  "tracing",
  "vec1",
  "walkdir",
@@ -2048,7 +2048,7 @@ dependencies = [
 
 [[package]]
 name = "pyrefly_derive"
-version = "0.24.0"
+version = "0.24.1"
 dependencies = [
  "proc-macro2",
  "quote",
@@ -2057,7 +2057,7 @@ dependencies = [
 
 [[package]]
 name = "pyrefly_python"
-version = "0.24.0"
+version = "0.24.1"
 dependencies = [
  "anyhow",
  "dupe",
@@ -2079,7 +2079,7 @@ dependencies = [
 
 [[package]]
 name = "pyrefly_util"
-version = "0.24.0"
+version = "0.24.1"
 dependencies = [
  "anstream",
  "anyhow",
@@ -2552,15 +2552,6 @@ dependencies = [
  "syn 2.0.101",
 ]
 
-[[package]]
-name = "serde_spanned"
-version = "0.6.8"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "87607cb1398ed59d48732e575a4c28a7a8ebf2454b964fe3f224f2afc07909e1"
-dependencies = [
- "serde",
-]
-
 [[package]]
 name = "serde_spanned"
 version = "1.0.0"
@@ -2988,23 +2979,17 @@ dependencies = [
 
 [[package]]
 name = "toml"
-version = "0.8.22"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "05ae329d1f08c4d17a59bed7ff5b5a769d062e64a62d34a3261b219e62cd5aae"
-dependencies = [
- "serde",
- "serde_spanned 0.6.8",
- "toml_datetime 0.6.9",
- "toml_edit 0.22.26",
-]
-
-[[package]]
-name = "toml_datetime"
-version = "0.6.9"
+version = "0.9.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3da5db5a963e24bc68be8b17b6fa82814bb22ee8660f192bb182771d498f09a3"
+checksum = "ed0aee96c12fa71097902e0bb061a5e1ebd766a6636bb605ba401c45c1650eac"
 dependencies = [
+ "indexmap",
  "serde",
+ "serde_spanned",
+ "toml_datetime",
+ "toml_parser",
+ "toml_writer",
+ "winnow",
 ]
 
 [[package]]
@@ -3016,20 +3001,6 @@ dependencies = [
  "serde",
 ]
 
-[[package]]
-name = "toml_edit"
-version = "0.22.26"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "310068873db2c5b3e7659d2cc35d21855dbafa50d1ce336397c666e3cb08137e"
-dependencies = [
- "indexmap",
- "serde",
- "serde_spanned 0.6.8",
- "toml_datetime 0.6.9",
- "toml_write",
- "winnow",
-]
-
 [[package]]
 name = "toml_edit"
 version = "0.23.1"
@@ -3038,8 +3009,8 @@ checksum = "b1f23a5f4511b296579b6c83e437fe85fa7ece22e3ec44e45ddb975bcf57c3dd"
 dependencies = [
  "indexmap",
  "serde",
- "serde_spanned 1.0.0",
- "toml_datetime 0.7.0",
+ "serde_spanned",
+ "toml_datetime",
  "toml_parser",
  "toml_writer",
  "winnow",
@@ -3054,12 +3025,6 @@ dependencies = [
  "winnow",
 ]
 
-[[package]]
-name = "toml_write"
-version = "0.1.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "bfb942dfe1d8e29a7ee7fcbde5bd2b9a25fb89aa70caea2eba3bee836ff41076"
-
 [[package]]
 name = "toml_writer"
 version = "1.0.2"

{pyrefly-0.24.0 → pyrefly-0.24.1}/PKG-INFO

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

{pyrefly-0.24.0 → pyrefly-0.24.1}/crates/pyrefly_python/Cargo.toml

@@ -2,7 +2,7 @@
 
 [package]
 name = "pyrefly_python"
-version = "0.24.0"
+version = "0.24.1"
 authors = ["Meta"]
 edition = "2024"
 repository = "https://github.com/facebook/pyrefly"
@@ -26,4 +26,4 @@ static_interner = "0.1.1"
 thiserror = "2.0.12"
 
 [dev-dependencies]
-toml = "0.8.22"
+toml = { version = "0.9.2", features = ["preserve_order"] }

{pyrefly-0.24.0/pyrefly/lib/module → pyrefly-0.24.1/crates/pyrefly_python/src}/display.rs

@@ -21,7 +21,7 @@ use ruff_text_size::Ranged;
 use ruff_text_size::TextRange;
 use ruff_text_size::TextSize;
 
-use crate::module::module_info::ModuleInfo;
+use crate::module_info::ModuleInfo;
 
 // Special module-specific types
 

{pyrefly-0.24.0 → pyrefly-0.24.1}/crates/pyrefly_python/src/dunder.rs

@@ -24,6 +24,7 @@ pub const EXIT: Name = Name::new_static("__exit__");
 pub const GE: Name = Name::new_static("__ge__");
 pub const GET: Name = Name::new_static("__get__");
 pub const GETATTR: Name = Name::new_static("__getattr__");
+pub const GETATTRIBUTE: Name = Name::new_static("__getattribute__");
 pub const GETITEM: Name = Name::new_static("__getitem__");
 pub const GT: Name = Name::new_static("__gt__");
 pub const HASH: Name = Name::new_static("__hash__");

{pyrefly-0.24.0 → pyrefly-0.24.1}/crates/pyrefly_python/src/ignore.rs

@@ -268,15 +268,15 @@ impl Ignore {
         // We allow an ignore on any line within the range.
         // We convert to/from zero-indexed because LineNumber does not implement Step.
         for line in start_line.to_zero_indexed()..=end_line.to_zero_indexed() {
-            if let Some(suppressions) = self.ignores.get(&LineNumber::from_zero_indexed(line)) {
-                if suppressions.iter().any(|supp| match supp.tool {
+            if let Some(suppressions) = self.ignores.get(&LineNumber::from_zero_indexed(line))
+                && suppressions.iter().any(|supp| match supp.tool {
                     // We only check the subkind if they do `# ignore: pyrefly`
                     Tool::Pyrefly => supp.kind.is_empty() || supp.kind.iter().any(|x| x == kind),
                     Tool::Any => true,
                     _ => permissive_ignores,
-                }) {
-                    return true;
-                }
+                })
+            {
+                return true;
             }
         }
 

{pyrefly-0.24.0 → pyrefly-0.24.1}/crates/pyrefly_python/src/lib.rs

@@ -20,9 +20,12 @@
 #![feature(let_chains)]
 
 pub mod ast;
+pub mod display;
 pub mod dunder;
 pub mod ignore;
+pub mod module_info;
 pub mod module_name;
 pub mod module_path;
+pub mod short_identifier;
 pub mod symbol_kind;
 pub mod sys_info;

{pyrefly-0.24.0/pyrefly/lib/module → pyrefly-0.24.1/crates/pyrefly_python/src}/module_info.rs

@@ -8,9 +8,6 @@
 use std::sync::Arc;
 
 use dupe::Dupe;
-use pyrefly_python::ignore::Ignore;
-use pyrefly_python::module_name::ModuleName;
-use pyrefly_python::module_path::ModulePath;
 use pyrefly_util::arc_id::ArcId;
 use pyrefly_util::lined_buffer::DisplayPos;
 use pyrefly_util::lined_buffer::DisplayRange;
@@ -18,16 +15,21 @@ use pyrefly_util::lined_buffer::LinedBuffer;
 use ruff_text_size::TextRange;
 use ruff_text_size::TextSize;
 
-use crate::error::kind::ErrorKind;
+use crate::ignore::Ignore;
+use crate::module_name::ModuleName;
+use crate::module_path::ModulePath;
 
 pub static GENERATED_TOKEN: &str = concat!("@", "generated");
 
+/// Legacy alias, to be deleted in due course.
+pub type ModuleInfo = Module;
+
 /// Information about a module, notably its name, path, and contents.
 #[derive(Debug, Clone, Dupe, PartialEq, Eq, Hash)]
-pub struct ModuleInfo(ArcId<ModuleInfoInner>);
+pub struct Module(ArcId<ModuleInner>);
 
 #[derive(Debug, Clone)]
-struct ModuleInfoInner {
+struct ModuleInner {
     name: ModuleName,
     path: ModulePath,
     ignore: Ignore,
@@ -41,7 +43,7 @@ impl ModuleInfo {
         let ignore = Ignore::new(&contents);
         let is_generated = contents.contains(GENERATED_TOKEN);
         let contents = LinedBuffer::new(contents);
-        Self(ArcId::new(ModuleInfoInner {
+        Self(ArcId::new(ModuleInner {
             name,
             path,
             ignore,
@@ -103,13 +105,13 @@ impl ModuleInfo {
     pub fn is_ignored(
         &self,
         source_range: &DisplayRange,
-        error_kind: ErrorKind,
+        error_kind: &str,
         permissive_ignores: bool,
     ) -> bool {
         self.0.ignore.is_ignored(
             source_range.start.line,
             source_range.end.line,
-            error_kind.to_name(),
+            error_kind,
             permissive_ignores,
         )
     }

{pyrefly-0.24.0/pyrefly/lib/module → pyrefly-0.24.1/crates/pyrefly_python/src}/short_identifier.rs

@@ -13,7 +13,7 @@ use ruff_python_ast::Identifier;
 use ruff_text_size::Ranged;
 use ruff_text_size::TextRange;
 
-use crate::module::module_info::ModuleInfo;
+use crate::module_info::ModuleInfo;
 
 /// An identifier, where we can drop the `Name` part because it came from a `ModuleInfo`.
 #[derive(Clone, Debug, PartialEq, Eq, Hash)]
@@ -47,12 +47,12 @@ mod tests {
     use std::path::Path;
     use std::sync::Arc;
 
-    use pyrefly_python::ast::Ast;
-    use pyrefly_python::module_name::ModuleName;
-    use pyrefly_python::module_path::ModulePath;
     use ruff_python_ast::Expr;
 
     use super::*;
+    use crate::ast::Ast;
+    use crate::module_name::ModuleName;
+    use crate::module_path::ModulePath;
 
     fn from_expr(x: &Expr) -> ShortIdentifier {
         match x {

{pyrefly-0.24.0 → pyrefly-0.24.1}/pyrefly/Cargo.toml

@@ -2,7 +2,7 @@
 
 [package]
 name = "pyrefly"
-version = "0.24.0"
+version = "0.24.1"
 authors = ["Meta"]
 edition = "2024"
 repository = "https://github.com/facebook/pyrefly"
@@ -55,7 +55,7 @@ static_assertions = "1.1.0"
 tar = "0.4.44"
 thiserror = "2.0.12"
 tokio = { version = "1.45.0", features = ["macros", "rt"] }
-toml = "0.8.22"
+toml = { version = "0.9.2", features = ["preserve_order"] }
 toml_edit = { version = "0.23.1", features = ["serde"] }
 tracing = { version = "0.1.41", features = ["attributes", "valuable"] }
 vec1 = { version = "1", features = ["serde"] }

{pyrefly-0.24.0 → pyrefly-0.24.1}/pyrefly/lib/alt/answers_solver.rs

@@ -280,13 +280,13 @@ impl Cycle {
     /// Do a post-calculation check, to track progress unwinding the cycle
     /// back toward the `break_at` as we produce final results.
     fn on_calculation_finished(&mut self, current: &CalcId) {
-        if let Some(c) = self.unwind_stack.last() {
-            if current == c {
-                // This is part of the cycle; remove it from the unwind stack.
-                let c = self.unwind_stack.pop().unwrap();
-                // Track what we unwound to make debugging easier.
-                self.unwound.push(c);
-            }
+        if let Some(c) = self.unwind_stack.last()
+            && current == c
+        {
+            // This is part of the cycle; remove it from the unwind stack.
+            let c = self.unwind_stack.pop().unwrap();
+            // Track what we unwound to make debugging easier.
+            self.unwound.push(c);
         }
     }
 }

{pyrefly-0.24.0 → pyrefly-0.24.1}/pyrefly/lib/alt/attr.rs

@@ -38,7 +38,7 @@ use crate::types::callable::Required;
 use crate::types::class::Class;
 use crate::types::class::ClassType;
 use crate::types::literal::Lit;
-use crate::types::module::Module;
+use crate::types::module::ModuleType;
 use crate::types::quantified::Quantified;
 use crate::types::quantified::QuantifiedKind;
 use crate::types::read_only::ReadOnlyReason;
@@ -211,11 +211,11 @@ enum AttributeInner {
     /// for the get and set actions.
     Descriptor(Descriptor),
     /// The attribute being looked up is not defined explicitly, but it may be defined via a
-    /// __getattr__ fallback.
+    /// `__getattr__` or `__getattribute__` fallback.
     /// The `NotFound` field stores the (failed) lookup result on the original attribute for
     /// better error reporting downstream. The `AttributeInner` field stores the (successful)
-    /// lookup result of the `__getattr__` function or method. The `Name` field stores the name
-    /// of the original attribute being looked up.
+    /// lookup result of the `__getattr__`/`__getattribute__` function or method.
+    /// The `Name` field stores the name of the original attribute being looked up.
     GetAttr(NotFound, Box<AttributeInner>, Name),
 }
 
@@ -248,7 +248,7 @@ pub enum DescriptorBase {
 pub enum NotFound {
     Attribute(Class),
     ClassAttribute(Class),
-    ModuleExport(Module),
+    ModuleExport(ModuleType),
 }
 
 #[derive(Clone, Debug)]
@@ -413,7 +413,7 @@ enum AttributeBase {
     EnumLiteral(ClassType, Name, Type),
     ClassInstance(ClassType),
     ClassObject(Class),
-    Module(Module),
+    Module(ModuleType),
     /// The attribute access is on a quantified type form (as in `args: P.args` - this
     /// is only used when the base *is* a quantified type, not when the base is
     /// a term that *has* a quantified type.
@@ -501,7 +501,7 @@ impl<'a, Ans: LookupAnswer> AnswersSolver<'a, Ans> {
         todo_ctx: &str,
     ) -> Type {
         let bases = self.get_possible_attribute_bases(base);
-        let mut results = Vec::new();
+        let mut results = Vec::with_capacity(bases.len());
         for attr_base in bases {
             let lookup_result = attr_base.map_or_else(
                 || LookupResult::InternalError(InternalError::AttributeBaseUndefined(base.clone())),
@@ -1438,6 +1438,13 @@ impl<'a, Ans: LookupAnswer> AnswersSolver<'a, Ans> {
             AttributeBase::ClassObject(class) => {
                 let metadata = self.get_metadata_for_class(class);
                 let metaclass = metadata.metaclass().unwrap_or(self.stdlib.builtins_type());
+                if *dunder_name == dunder::GETATTRIBUTE
+                    && self.method_is_inherited_from_object(metaclass, dunder_name)
+                {
+                    return LookupResult::NotFound(NotFound::Attribute(
+                        metaclass.class_object().clone(),
+                    ));
+                }
                 match self.get_instance_attribute(metaclass, dunder_name) {
                     Some(attr) => LookupResult::Found(attr),
                     None => LookupResult::NotFound(NotFound::Attribute(
@@ -1448,12 +1455,17 @@ impl<'a, Ans: LookupAnswer> AnswersSolver<'a, Ans> {
             AttributeBase::ClassInstance(cls)
             | AttributeBase::EnumLiteral(cls, _, _)
             | AttributeBase::TypeVar(_, Some(cls))
-                if (*dunder_name == dunder::SETATTR || *dunder_name == dunder::DELATTR)
+            | AttributeBase::SuperInstance(cls, _)
+                if (*dunder_name == dunder::SETATTR
+                    || *dunder_name == dunder::DELATTR
+                    || *dunder_name == dunder::GETATTRIBUTE)
                     && self.method_is_inherited_from_object(cls, dunder_name) =>
             {
                 LookupResult::NotFound(NotFound::Attribute(cls.class_object().clone()))
             }
-
+            AttributeBase::TypedDict(typed_dict) if *dunder_name == dunder::GETATTRIBUTE => {
+                LookupResult::NotFound(NotFound::Attribute(typed_dict.class_object().clone()))
+            }
             _ => self.lookup_attr_from_attribute_base(base, dunder_name),
         }
     }
@@ -1467,10 +1479,26 @@ impl<'a, Ans: LookupAnswer> AnswersSolver<'a, Ans> {
         match direct_lookup_result {
             LookupResult::Found(_) | LookupResult::InternalError(_) => direct_lookup_result,
             LookupResult::NotFound(not_found) => {
-                let getattr_lookup_result = self.lookup_magic_dunder_attr(base, &dunder::GETATTR);
+                let getattr_lookup_result =
+                    self.lookup_magic_dunder_attr(base.clone(), &dunder::GETATTR);
                 match getattr_lookup_result {
                     LookupResult::NotFound(_) | LookupResult::InternalError(_) => {
-                        LookupResult::NotFound(not_found)
+                        // If the `__getattr__` lookup fails, we fall back to `__getattribute__`
+                        // Note: at runtime, `__getattribute__` is checked BEFORE looking up the attribute by name,
+                        // but because the declaration is on `object` and returns `Any`, all attribute accesses
+                        // would return `Any`.
+                        let getattribute_lookup_result =
+                            self.lookup_magic_dunder_attr(base, &dunder::GETATTRIBUTE);
+                        match getattribute_lookup_result {
+                            LookupResult::NotFound(_) | LookupResult::InternalError(_) => {
+                                LookupResult::NotFound(not_found)
+                            }
+                            LookupResult::Found(attr) => LookupResult::Found(Attribute::getattr(
+                                not_found,
+                                attr,
+                                attr_name.clone(),
+                            )),
+                        }
                     }
                     LookupResult::Found(attr) => {
                         LookupResult::Found(Attribute::getattr(not_found, attr, attr_name.clone()))
@@ -1530,21 +1558,7 @@ impl<'a, Ans: LookupAnswer> AnswersSolver<'a, Ans> {
         self.exports.get(module_name).ok()
     }
 
-    fn get_exported_type(&self, exports: &Exports, from: ModuleName, name: &Name) -> Option<Type> {
-        if exports.exports(self.exports).contains_key(name) {
-            Some(
-                self.get_from_export(from, None, &KeyExport(name.clone()))
-                    .arc_clone(),
-            )
-        } else {
-            None
-        }
-    }
-
-    fn get_module_attr(&self, module: &Module, attr_name: &Name) -> Option<Type> {
-        let module_name = ModuleName::from_parts(module.parts());
-        let module_exports = self.get_module_exports(module_name);
-
+    fn get_module_attr(&self, module: &ModuleType, attr_name: &Name) -> Option<Type> {
         // `module_name` could refer to a package, in which case we need to check if
         // `module_name.attr_name`:
         // - Has been imported. This can happen in two ways:
@@ -1558,17 +1572,29 @@ impl<'a, Ans: LookupAnswer> AnswersSolver<'a, Ans> {
         // 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_part(attr_name.clone());
-        let submodule_name = module_name.append(attr_name);
-        let is_imported = submodule.is_submodules_imported_directly()
-            || module_exports
-                .as_ref()
-                .is_some_and(|exports| exports.is_submodule_imported_implicitly(attr_name));
-        if is_imported && self.get_module_exports(submodule_name).is_some() {
+        if submodule.is_submodules_imported_directly() {
+            return Some(submodule.to_type());
+        }
+
+        let module_name = ModuleName::from_parts(module.parts());
+        let module_exports = match self.get_module_exports(module_name) {
+            Some(x) => x,
+            None => return Some(Type::any_error()), // This module doesn't exist, we must have already errored
+        };
+
+        if module_exports.is_submodule_imported_implicitly(attr_name)
+            && self
+                .get_module_exports(module_name.append(attr_name))
+                .is_some()
+        {
             Some(submodule.to_type())
+        } else if module_exports.exports(self.exports).contains_key(attr_name) {
+            Some(
+                self.get_from_export(module_name, None, &KeyExport(attr_name.clone()))
+                    .arc_clone(),
+            )
         } else {
-            module_exports.map_or(Some(Type::any_error()), |exports| {
-                self.get_exported_type(&exports, module_name, attr_name)
-            })
+            None
         }
     }
 
@@ -1836,7 +1862,7 @@ impl<'a, Ans: LookupAnswer> AnswersSolver<'a, Ans> {
 
     fn completions_module(
         &self,
-        module: &Module,
+        module: &ModuleType,
         expected_attribute_name: Option<&Name>,
         res: &mut Vec<AttrInfo>,
     ) {

{pyrefly-0.24.0 → pyrefly-0.24.1}/pyrefly/lib/alt/call.rs

@@ -255,7 +255,7 @@ impl<'a, Ans: LookupAnswer> AnswersSolver<'a, Ans> {
             None => {
                 let expect_message = match call_style {
                     CallStyle::Method(method) => {
-                        format!("Expected `{}` to be a callable", method)
+                        format!("Expected `{method}` to be a callable")
                     }
                     CallStyle::FreeForm => "Expected a callable".to_owned(),
                 };

{pyrefly-0.24.0 → pyrefly-0.24.1}/pyrefly/lib/alt/callable.rs

@@ -605,7 +605,7 @@ impl<'a, Ans: LookupAnswer> AnswersSolver<'a, Ans> {
             } else if num_positional_params < 1 {
                 (
                     "0 positional arguments".to_owned(),
-                    format!("{} (including implicit `self`)", num_positional_args),
+                    format!("{num_positional_args} (including implicit `self`)"),
                 )
             } else {
                 (
@@ -616,7 +616,7 @@ impl<'a, Ans: LookupAnswer> AnswersSolver<'a, Ans> {
             error(
                 call_errors,
                 arg_range,
-                ErrorKind::BadArgumentType,
+                ErrorKind::BadArgumentCount,
                 format!("Expected {expected}, got {actual}"),
             );
         }
@@ -674,14 +674,14 @@ impl<'a, Ans: LookupAnswer> AnswersSolver<'a, Ans> {
                     call_errors,
                     range,
                     ErrorKind::UnexpectedKeyword,
-                    format!("Expected argument `{}` to be positional", name),
+                    format!("Expected argument `{name}` to be positional"),
                 );
             } else {
                 error(
                     call_errors,
                     range,
                     ErrorKind::UnexpectedKeyword,
-                    format!("Unexpected keyword argument `{}`", name),
+                    format!("Unexpected keyword argument `{name}`"),
                 );
             }
         };
@@ -698,7 +698,7 @@ impl<'a, Ans: LookupAnswer> AnswersSolver<'a, Ans> {
                                     call_errors,
                                     kw.range,
                                     ErrorKind::BadKeywordArgument,
-                                    format!("Multiple values for argument `{}`", name),
+                                    format!("Multiple values for argument `{name}`"),
                                 );
                                 hint = Some(ty.clone());
                             } else if let Some((ty, required)) = kwparams.get(name) {
@@ -708,7 +708,7 @@ impl<'a, Ans: LookupAnswer> AnswersSolver<'a, Ans> {
                                         call_errors,
                                         kw.range,
                                         ErrorKind::MissingArgument,
-                                        format!("Expected key `{}` to be required", name),
+                                        format!("Expected key `{name}` to be required"),
                                     );
                                 }
                                 hint = Some(ty.clone())
@@ -857,7 +857,7 @@ impl<'a, Ans: LookupAnswer> AnswersSolver<'a, Ans> {
                         call_errors,
                         range,
                         ErrorKind::MissingArgument,
-                        format!("Missing argument `{}`", name),
+                        format!("Missing argument `{name}`"),
                     );
                 }
                 for (ty, range) in &splat_kwargs {