pyrefly 0.19.2__tar.gz → 0.20.1__tar.gz

{pyrefly-0.19.2 → pyrefly-0.20.1}/Cargo.lock

@@ -239,9 +239,9 @@ checksum = "5c8214115b7bf84099f1309324e63141d4c5d7cc26862f97a0a857dbefe165bd"
 
 [[package]]
 name = "blake3"
-version = "1.5.5"
+version = "1.6.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b8ee0c1824c4dea5b5f81736aff91bae041d2c07ee1192bec91054e10e3e601e"
+checksum = "675f87afced0413c9bb02843499dbbd3882a237645883f71a2b59644a6d2f753"
 dependencies = [
  "arrayref",
  "arrayvec",
@@ -322,14 +322,14 @@ checksum = "baf1de4339761588bc0619e3cbc0120ee582ebb74b53b4efbf79117bd2da40fd"
 
 [[package]]
 name = "chrono"
-version = "0.4.39"
+version = "0.4.41"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7e36cc9d416881d2e24f9a963be5fb1cd90966419ac844274161d10488b3e825"
+checksum = "c469d952047f47f91b68d1cba3f10d63c11d73e4636f24f08daf0278abf01c4d"
 dependencies = [
  "android-tzdata",
  "iana-time-zone",
  "num-traits",
- "windows-targets 0.52.6",
+ "windows-link",
 ]
 
 [[package]]
@@ -765,9 +765,9 @@ checksum = "3f9eec918d3f24069decb9af1554cad7c880e2da24a9afd88aca000531ab82c1"
 
 [[package]]
 name = "foldhash"
-version = "0.1.4"
+version = "0.1.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a0d2fde1f7b3d48b8395d5f2de76c18a528bd6a9cdde438df747bfcba3e05d6f"
+checksum = "d9c4f5dac5e15c24eb999c26181a6ca40b39fe946cbe4c263c7209467bc83af2"
 
 [[package]]
 name = "form_urlencoded"
@@ -1841,7 +1841,7 @@ dependencies = [
 
 [[package]]
 name = "pyrefly"
-version = "0.19.2"
+version = "0.20.1"
 dependencies = [
  "anstream",
  "anyhow",
@@ -1899,7 +1899,7 @@ dependencies = [
 
 [[package]]
 name = "pyrefly_derive"
-version = "0.19.2"
+version = "0.20.1"
 dependencies = [
  "proc-macro2",
  "quote",
@@ -1908,7 +1908,7 @@ dependencies = [
 
 [[package]]
 name = "pyrefly_util"
-version = "0.19.2"
+version = "0.20.1"
 dependencies = [
  "anstream",
  "anyhow",
@@ -2250,9 +2250,9 @@ checksum = "764cad9e7e1ca5fe15b552859ff5d96a314e6ed2934f2260168cd5dfa5891409"
 
 [[package]]
 name = "serde"
-version = "1.0.217"
+version = "1.0.219"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "02fc4265df13d6fa1d00ecff087228cc0a2b5f3c0e87e258d8b94a156e984c70"
+checksum = "5f0e2c6ed6606019b4e29e69dbaba95b11854410e5347d525002456dbbb786b6"
 dependencies = [
  "serde_derive",
 ]
@@ -2293,9 +2293,9 @@ dependencies = [
 
 [[package]]
 name = "serde_derive"
-version = "1.0.217"
+version = "1.0.219"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5a9bf7cf98d04a2b28aead066b7496853d4779c9cc183c440dbac457641e19a0"
+checksum = "5b0276cf7f2c73365f7157c8123c21cd9a50fbbd844757af28ca1f5925fc2a00"
 dependencies = [
  "proc-macro2",
  "quote",
@@ -2909,9 +2909,9 @@ checksum = "a210d160f08b701c8721ba1c726c11662f877ea6b7094007e1ca9a1041945034"
 
 [[package]]
 name = "unicode-normalization"
-version = "0.1.23"
+version = "0.1.24"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a56d1686db2308d901306f92a263857ef59ea39678a5458e7cb17f01415101f5"
+checksum = "5033c97c4262335cded6d6fc3e5c18ab755e1a3dc96376350f3d8e9f009ad956"
 dependencies = [
  "tinyvec",
 ]
@@ -3160,6 +3160,12 @@ version = "0.4.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "712e227841d057c1ee1cd2fb22fa7e5a5461ae8e48fa2ca79ec42cfc1931183f"
 
+[[package]]
+name = "windows-link"
+version = "0.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "76840935b766e1b0a05c0066835fb9ec80071d4c09a16f6bd5f7e655e3c14c38"
+
 [[package]]
 name = "windows-sys"
 version = "0.45.0"

{pyrefly-0.19.2 → pyrefly-0.20.1}/PKG-INFO

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

{pyrefly-0.19.2 → pyrefly-0.20.1}/pyrefly/Cargo.toml

@@ -2,7 +2,7 @@
 
 [package]
 name = "pyrefly"
-version = "0.19.2"
+version = "0.20.1"
 authors = ["Meta"]
 edition = "2024"
 repository = "https://github.com/facebook/pyrefly"
@@ -20,8 +20,8 @@ path = "bin/main.rs"
 anstream = "0.6.11"
 anyhow = "1.0.95"
 append-only-vec = "0.1.2"
-base64 = "0.22.1"
-blake3 = { version = "=1.5.5", features = ["mmap", "rayon", "traits-preview"] }
+base64 = { version = "0.22.1", features = ["alloc"] }
+blake3 = { version = "=1.6.1", features = ["mmap", "rayon", "traits-preview"] }
 clap = { version = "4.5.38", features = ["derive", "env", "string", "unicode", "wrap_help"] }
 configparser = { version = "3.0.3", features = ["indexmap"] }
 convert_case = "0.6"

{pyrefly-0.19.2 → pyrefly-0.20.1}/pyrefly/lib/alt/answers.rs

@@ -324,7 +324,6 @@ impl Solutions {
     }
 }
 
-#[derive(Clone)]
 pub struct AnswersSolver<'a, Ans: LookupAnswer> {
     answers: &'a Ans,
     current: &'a Answers,

{pyrefly-0.19.2 → pyrefly-0.20.1}/pyrefly/lib/alt/attr.rs

@@ -8,8 +8,6 @@
 use std::iter;
 
 use dupe::Dupe;
-use itertools::Either;
-use ruff_python_ast::Expr;
 use ruff_python_ast::name::Name;
 use ruff_text_size::TextRange;
 use starlark_map::small_set::SmallSet;
@@ -17,6 +15,7 @@ use starlark_map::small_set::SmallSet;
 use crate::alt::answers::AnswersSolver;
 use crate::alt::answers::LookupAnswer;
 use crate::alt::callable::CallArg;
+use crate::alt::expr::TypeOrExpr;
 use crate::alt::types::class_metadata::EnumMetadata;
 use crate::binding::binding::ExprOrBinding;
 use crate::binding::binding::KeyExport;
@@ -59,6 +58,110 @@ enum LookupResult {
     InternalError(InternalError),
 }
 
+#[derive(Debug)]
+pub enum AttrSubsetError {
+    // `got` is not accessible, but `want` is
+    NoAccess,
+    // `got` is a property, but `want` is not
+    Property,
+    // `got` is read-only, but `want` is read-write
+    ReadOnly,
+    // one of `got` or `want` is a descriptor, the other is not
+    Descriptor,
+    // either `got` or `want` is a call to `__getattr__`
+    Getattr,
+    // `got` is not a subtype of `want`
+    // applies to methods, read-only attributes, and property getters
+    Covariant {
+        got: Type,
+        want: Type,
+        got_is_property: bool,
+        want_is_property: bool,
+    },
+    // `got` and `want` are not subtypes of each other
+    // applies to read-write attributes
+    Invariant {
+        got: Type,
+        want: Type,
+    },
+    // `want` is not a subtype of `got`
+    // applies to property setters
+    Contravariant {
+        got: Type,
+        want: Type,
+        got_is_property: bool,
+    },
+}
+
+impl AttrSubsetError {
+    pub fn to_error_msg(self, child_class: &Name, parent_class: &Name, attr_name: &Name) -> String {
+        match self {
+            AttrSubsetError::NoAccess => {
+                format!("`{child_class}.{attr_name}` is not accessible from the instance")
+            }
+            AttrSubsetError::Property => {
+                format!(
+                    "`{child_class}.{attr_name}` is a property, but `{parent_class}.{attr_name}` is not"
+                )
+            }
+            AttrSubsetError::ReadOnly => {
+                format!(
+                    "`{child_class}.{attr_name}` is read-only, but `{parent_class}.{attr_name}` is read-write"
+                )
+            }
+            AttrSubsetError::Descriptor => {
+                format!(
+                    "`{child_class}.{attr_name}` and `{parent_class}.{attr_name}` must both be descriptors"
+                )
+            }
+            AttrSubsetError::Getattr => {
+                format!(
+                    "`{child_class}.{attr_name}` or `{parent_class}.{attr_name}` uses `__getattr__`, which cannot be checked for override compatibility"
+                )
+            }
+            AttrSubsetError::Covariant {
+                got,
+                want,
+                got_is_property,
+                want_is_property,
+            } => {
+                let got_desc = if got_is_property {
+                    "Property getter for "
+                } else {
+                    ""
+                };
+                let want_desc = if want_is_property {
+                    ", the property getter for "
+                } else {
+                    ", the type of "
+                };
+                format!(
+                    "{got_desc}`{child_class}.{attr_name}` has type `{got}`, which is not assignable to `{want}`{want_desc}`{parent_class}.{attr_name}`"
+                )
+            }
+            AttrSubsetError::Invariant { got, want } => {
+                format!(
+                    "`{child_class}.{attr_name}` has type `{got}`, which is not consistent with `{want}` in `{parent_class}.{attr_name}` (the type of read-write attributes cannot be changed)"
+                )
+            }
+            AttrSubsetError::Contravariant {
+                got,
+                want,
+                got_is_property,
+            } => {
+                let desc = if got_is_property {
+                    "The property setter for "
+                } else {
+                    ""
+                };
+                format!(
+                    "{desc}`{child_class}.{attr_name}` has type `{got}`, which is not assignable from `{want}`, the property getter for `{parent_class}.{attr_name}`"
+                )
+            }
+        }
+    }
+}
+
 /// The result of a read for narrowing purposes. We track whether we are narrowing
 /// a property or descriptor that might not be idempotent, and if so we also
 /// indicate when this came through a union (so that error messages can be clearer).
@@ -499,10 +602,12 @@ impl<'a, Ans: LookupAnswer> AnswersSolver<'a, Ans> {
         range: TextRange,
         errors: &ErrorCollector,
     ) -> Option<Type> {
+        let ty;
         let got = match got {
-            ExprOrBinding::Expr(value) => Either::Left(value),
+            ExprOrBinding::Expr(value) => TypeOrExpr::Expr(value),
             ExprOrBinding::Binding(got) => {
-                Either::Right(self.solve_binding(got, errors).arc_clone_ty())
+                ty = self.solve_binding(got, errors);
+                TypeOrExpr::Type(ty.ty(), range)
             }
         };
         self.check_attr_set_and_infer_narrow(
@@ -520,7 +625,7 @@ impl<'a, Ans: LookupAnswer> AnswersSolver<'a, Ans> {
         &self,
         base: &Type,
         attr_name: &Name,
-        got: Either<&Expr, Type>,
+        got: TypeOrExpr,
         range: TextRange,
         errors: &ErrorCollector,
         context: Option<&dyn Fn() -> ErrorContext>,
@@ -537,7 +642,7 @@ impl<'a, Ans: LookupAnswer> AnswersSolver<'a, Ans> {
                 LookupResult::Found(attr) => match attr.inner {
                     AttributeInner::Simple(want, Visibility::ReadWrite) => {
                         let ty = match &got {
-                            Either::Left(got) => self.expr(
+                            TypeOrExpr::Expr(got) => self.expr(
                                 got,
                                 Some((&want, &|| TypeCheckContext {
                                     kind: TypeCheckKind::Attribute(attr_name.clone()),
@@ -545,12 +650,12 @@ impl<'a, Ans: LookupAnswer> AnswersSolver<'a, Ans> {
                                 })),
                                 errors,
                             ),
-                            Either::Right(got) => {
+                            TypeOrExpr::Type(got, _) => {
                                 self.check_type(&want, got, range, errors, &|| TypeCheckContext {
                                     kind: TypeCheckKind::Attribute(attr_name.clone()),
                                     context: context.map(|ctx| ctx()),
                                 });
-                                got.clone()
+                                (*got).clone()
                             }
                         };
                         if let Some(narrowed_types) = &mut narrowed_types {
@@ -588,19 +693,13 @@ impl<'a, Ans: LookupAnswer> AnswersSolver<'a, Ans> {
                         );
                     }
                     AttributeInner::Property(_, Some(setter), _) => {
-                        let got = match &got {
-                            Either::Left(got) => CallArg::Expr(got),
-                            Either::Right(got) => CallArg::Type(got, range),
-                        };
+                        let got = CallArg::arg(got);
                         self.call_property_setter(setter, got, range, errors, context);
                     }
                     AttributeInner::Descriptor(d) => {
                         match (d.base, d.setter) {
                             (DescriptorBase::Instance(class_type), Some(setter)) => {
-                                let got = match &got {
-                                    Either::Left(got) => CallArg::Expr(got),
-                                    Either::Right(got) => CallArg::Type(got, range),
-                                };
+                                let got = CallArg::arg(got);
                                 self.call_descriptor_setter(
                                     setter, class_type, got, range, errors, context,
                                 );
@@ -741,44 +840,86 @@ impl<'a, Ans: LookupAnswer> AnswersSolver<'a, Ans> {
         }
     }
 
-    pub fn is_attr_subset(
+    pub fn check_attr_subset(
         &self,
         got: &Attribute,
         want: &Attribute,
         is_subset: &mut dyn FnMut(&Type, &Type) -> bool,
-    ) -> bool {
+    ) -> Result<(), AttrSubsetError> {
         match (&got.inner, &want.inner) {
-            (_, AttributeInner::NoAccess(_)) => true,
-            (AttributeInner::NoAccess(_), _) => false,
-            (AttributeInner::Property(_, _, _), AttributeInner::Simple(..)) => false,
+            (_, AttributeInner::NoAccess(_)) => Ok(()),
+            (AttributeInner::NoAccess(_), _) => Err(AttrSubsetError::NoAccess),
+            (AttributeInner::Property(_, _, _), AttributeInner::Simple(..)) => {
+                Err(AttrSubsetError::Property)
+            }
             (
                 AttributeInner::Simple(_, Visibility::ReadOnly),
                 AttributeInner::Property(_, Some(_), _)
                 | AttributeInner::Simple(_, Visibility::ReadWrite),
-            ) => false,
+            ) => Err(AttrSubsetError::ReadOnly),
             (
                 // TODO(stroxler): Investigate this case more: methods should be ReadOnly, but
                 // in some cases for unknown reasons they wind up being ReadWrite.
                 AttributeInner::Simple(got @ Type::BoundMethod(_), Visibility::ReadWrite),
                 AttributeInner::Simple(want @ Type::BoundMethod(_), Visibility::ReadWrite),
-            ) => is_subset(got, want),
+            ) => {
+                if is_subset(got, want) {
+                    Ok(())
+                } else {
+                    Err(AttrSubsetError::Covariant {
+                        got: got.clone(),
+                        want: want.clone(),
+                        got_is_property: false,
+                        want_is_property: false,
+                    })
+                }
+            }
             (
                 AttributeInner::Simple(got, Visibility::ReadWrite),
                 AttributeInner::Simple(want, Visibility::ReadWrite),
-            ) => is_subset(got, want) && is_subset(want, got),
+            ) => {
+                if is_subset(got, want) && is_subset(want, got) {
+                    Ok(())
+                } else {
+                    Err(AttrSubsetError::Invariant {
+                        got: got.clone(),
+                        want: want.clone(),
+                    })
+                }
+            }
             (
                 AttributeInner::Simple(got, ..),
                 AttributeInner::Simple(want, Visibility::ReadOnly),
-            ) => is_subset(got, want),
+            ) => {
+                if is_subset(got, want) {
+                    Ok(())
+                } else {
+                    Err(AttrSubsetError::Covariant {
+                        got: got.clone(),
+                        want: want.clone(),
+                        got_is_property: false,
+                        want_is_property: false,
+                    })
+                }
+            }
             (
                 AttributeInner::Simple(got, Visibility::ReadOnly),
                 AttributeInner::Property(want, _, _),
             ) => {
-                is_subset(
+                if is_subset(
                     // Synthesize a getter method
                     &Type::callable_ellipsis(got.clone()),
                     want,
-                )
+                ) {
+                    Ok(())
+                } else {
+                    Err(AttrSubsetError::Covariant {
+                        got: got.clone(),
+                        want: want.clone(),
+                        got_is_property: false,
+                        want_is_property: true,
+                    })
+                }
             }
             (
                 AttributeInner::Simple(got, Visibility::ReadWrite),
@@ -789,19 +930,32 @@ impl<'a, Ans: LookupAnswer> AnswersSolver<'a, Ans> {
                     &Type::callable_ellipsis(got.clone()),
                     want,
                 ) {
-                    return false;
+                    return Err(AttrSubsetError::Covariant {
+                        got: got.clone(),
+                        want: want.clone(),
+                        got_is_property: false,
+                        want_is_property: true,
+                    });
                 }
                 if let Some(want_setter) = want_setter {
                     // Synthesize a setter method
-                    is_subset(
+                    if is_subset(
                         want_setter,
                         &Type::callable(
                             vec![Param::PosOnly(None, got.clone(), Required::Required)],
                             Type::None,
                         ),
-                    )
+                    ) {
+                        Ok(())
+                    } else {
+                        Err(AttrSubsetError::Contravariant {
+                            want: want_setter.clone(),
+                            got: got.clone(),
+                            got_is_property: true,
+                        })
+                    }
                 } else {
-                    true
+                    Ok(())
                 }
             }
             (
@@ -809,12 +963,27 @@ impl<'a, Ans: LookupAnswer> AnswersSolver<'a, Ans> {
                 AttributeInner::Property(want_getter, want_setter, _),
             ) => {
                 if !is_subset(got_getter, want_getter) {
-                    false
+                    Err(AttrSubsetError::Covariant {
+                        got: got_getter.clone(),
+                        want: want_getter.clone(),
+                        got_is_property: true,
+                        want_is_property: true,
+                    })
                 } else {
                     match (got_setter, want_setter) {
-                        (Some(got_setter), Some(want_setter)) => is_subset(got_setter, want_setter),
-                        (None, Some(_)) => false,
-                        (_, None) => true,
+                        (Some(got_setter), Some(want_setter)) => {
+                            if is_subset(got_setter, want_setter) {
+                                Ok(())
+                            } else {
+                                Err(AttrSubsetError::Contravariant {
+                                    want: want_setter.clone(),
+                                    got: got_setter.clone(),
+                                    got_is_property: true,
+                                })
+                            }
+                        }
+                        (None, Some(_)) => Err(AttrSubsetError::ReadOnly),
+                        (_, None) => Ok(()),
                     }
                 }
             }
@@ -833,12 +1002,25 @@ impl<'a, Ans: LookupAnswer> AnswersSolver<'a, Ans> {
                     },
                     ..,
                 ),
-            ) => is_subset(got_ty, want_ty),
-            (AttributeInner::Descriptor(..), _) | (_, AttributeInner::Descriptor(..)) => false,
+            ) => {
+                if is_subset(got_ty, want_ty) {
+                    Ok(())
+                } else {
+                    Err(AttrSubsetError::Covariant {
+                        got: got_ty.clone(),
+                        want: want_ty.clone(),
+                        got_is_property: false,
+                        want_is_property: false,
+                    })
+                }
+            }
+            (AttributeInner::Descriptor(..), _) | (_, AttributeInner::Descriptor(..)) => {
+                Err(AttrSubsetError::Descriptor)
+            }
             (AttributeInner::GetAttr(..), _) | (_, AttributeInner::GetAttr(..)) => {
                 // NOTE(grievejia): `__getattr__` does not participate in structural subtyping
                 // check for now. We may revisit this in the future if the need comes.
-                false
+                Err(AttrSubsetError::Getattr)
             }
         }
     }