pyrefly 0.20.0__tar.gz → 0.20.1__tar.gz

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

@@ -1841,7 +1841,7 @@ dependencies = [
 
 [[package]]
 name = "pyrefly"
-version = "0.20.0"
+version = "0.20.1"
 dependencies = [
  "anstream",
  "anyhow",
@@ -1899,7 +1899,7 @@ dependencies = [
 
 [[package]]
 name = "pyrefly_derive"
-version = "0.20.0"
+version = "0.20.1"
 dependencies = [
  "proc-macro2",
  "quote",
@@ -1908,7 +1908,7 @@ dependencies = [
 
 [[package]]
 name = "pyrefly_util"
-version = "0.20.0"
+version = "0.20.1"
 dependencies = [
  "anstream",
  "anyhow",

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

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

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

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

{pyrefly-0.20.0 → 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.20.0 → pyrefly-0.20.1}/pyrefly/lib/alt/attr.rs

@@ -58,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).
@@ -736,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),
@@ -784,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(())
                 }
             }
             (
@@ -804,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(()),
                     }
                 }
             }
@@ -828,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)
             }
         }
     }

{pyrefly-0.20.0 → pyrefly-0.20.1}/pyrefly/lib/alt/call.rs

@@ -8,7 +8,6 @@
 use append_only_vec::AppendOnlyVec;
 use dupe::Dupe;
 use ruff_python_ast::name::Name;
-use ruff_text_size::Ranged;
 use ruff_text_size::TextRange;
 use starlark_map::small_set::SmallSet;
 use vec1::Vec1;
@@ -19,7 +18,7 @@ use crate::alt::answers::LookupAnswer;
 use crate::alt::attr::DescriptorBase;
 use crate::alt::callable::CallArg;
 use crate::alt::callable::CallKeyword;
-use crate::alt::expr::TypeOrExpr;
+use crate::alt::callable::CallWithTypes;
 use crate::dunder;
 use crate::error::collector::ErrorCollector;
 use crate::error::context::ErrorContext;
@@ -652,66 +651,15 @@ impl<'a, Ans: LookupAnswer> AnswersSolver<'a, Ans> {
         errors: &ErrorCollector,
         context: Option<&dyn Fn() -> ErrorContext>,
     ) -> Type {
-        self.call_overloads_with_store(
-            &AppendOnlyVec::new(),
-            overloads,
-            metadata,
-            self_arg,
-            args,
-            keywords,
-            range,
-            errors,
-            context,
-        )
-    }
-
-    fn call_overloads_with_store<'t>(
-        &self,
-        type_store: &'t AppendOnlyVec<Type>,
-        overloads: Vec1<Callable>,
-        metadata: FuncMetadata,
-        self_arg: Option<CallArg<'t>>,
-        args: &[CallArg<'t>],
-        keywords: &[CallKeyword<'t>],
-        range: TextRange,
-        errors: &ErrorCollector,
-        context: Option<&dyn Fn() -> ErrorContext>,
-    ) -> Type {
-        let type_or_expr = |x: TypeOrExpr<'t>| -> TypeOrExpr<'t> {
-            match x {
-                TypeOrExpr::Expr(e) => {
-                    let t = self.expr_infer(e, errors);
-                    let i = type_store.push(t);
-                    TypeOrExpr::Type(&type_store[i], e.range())
-                }
-                TypeOrExpr::Type(t, r) => TypeOrExpr::Type(t, r),
-            }
-        };
-        let call_arg = |x: CallArg<'t>| -> CallArg<'t> {
-            match x {
-                CallArg::Arg(x) => CallArg::Arg(type_or_expr(x)),
-                CallArg::Star(x, r) => CallArg::Star(type_or_expr(x), r),
-            }
-        };
-        let call_keyword = |x: CallKeyword<'t>| -> CallKeyword<'t> {
-            CallKeyword {
-                range: x.range,
-                arg: x.arg,
-                value: type_or_expr(x.value),
-            }
-        };
-
         // There may be Expr values in self_arg, args and keywords.
         // If we infer them for each overload, we may end up infering them multiple times.
         // If those overloads contain nested overloads, then we can easily end up with O(2^n) perf.
         // Therefore, flatten all TypeOrExpr's into Type before we start
-        let self_arg = self_arg.map(call_arg);
-        let args = args.iter().cloned().map(&call_arg).collect::<Vec<_>>();
-        let keywords = keywords
-            .iter()
-            .cloned()
-            .map(&call_keyword)
-            .collect::<Vec<_>>();
+        let type_store = AppendOnlyVec::new();
+        let call = CallWithTypes::new(&type_store);
+        let self_arg = call.opt_call_arg(self_arg.as_ref(), self, errors);
+        let args = call.vec_call_arg(args, self, errors);
+        let keywords = call.vec_call_keyword(keywords, self, errors);
 
         let mut closest_overload: Option<CalledOverload> = None;
         for callable in overloads.iter() {

{pyrefly-0.20.0 → pyrefly-0.20.1}/pyrefly/lib/alt/callable.rs

@@ -8,6 +8,7 @@
 use append_only_vec::AppendOnlyVec;
 use itertools::Itertools;
 use pyrefly_util::display::count;
+use pyrefly_util::prelude::SliceExt;
 use pyrefly_util::prelude::VecExt;
 use ruff_python_ast::Expr;
 use ruff_python_ast::Identifier;
@@ -39,6 +40,82 @@ use crate::types::tuple::Tuple;
 use crate::types::types::Type;
 use crate::types::types::Var;
 
+pub struct CallWithTypes<'a>(&'a AppendOnlyVec<Type>);
+
+impl<'a> CallWithTypes<'a> {
+    pub fn new(x: &'a AppendOnlyVec<Type>) -> Self {
+        Self(x)
+    }
+
+    pub fn type_or_expr<'b: 'a, Ans: LookupAnswer>(
+        &self,
+        x: TypeOrExpr<'b>,
+        solver: &AnswersSolver<Ans>,
+        errors: &ErrorCollector,
+    ) -> TypeOrExpr<'a> {
+        match x {
+            TypeOrExpr::Expr(e) => {
+                let t = solver.expr_infer(e, errors);
+                let i = self.0.push(t);
+                TypeOrExpr::Type(&self.0[i], e.range())
+            }
+            TypeOrExpr::Type(t, r) => TypeOrExpr::Type(t, r),
+        }
+    }
+
+    pub fn call_arg<'b: 'a, Ans: LookupAnswer>(
+        &self,
+        x: &CallArg<'b>,
+        solver: &AnswersSolver<Ans>,
+        errors: &ErrorCollector,
+    ) -> CallArg<'a> {
+        match x {
+            CallArg::Arg(x) => CallArg::Arg(self.type_or_expr(*x, solver, errors)),
+            CallArg::Star(x, r) => CallArg::Star(self.type_or_expr(*x, solver, errors), *r),
+        }
+    }
+
+    pub fn call_keyword<'b: 'a, Ans: LookupAnswer>(
+        &self,
+        x: &CallKeyword<'b>,
+        solver: &AnswersSolver<Ans>,
+        errors: &ErrorCollector,
+    ) -> CallKeyword<'a> {
+        CallKeyword {
+            range: x.range,
+            arg: x.arg,
+            value: self.type_or_expr(x.value, solver, errors),
+        }
+    }
+
+    pub fn opt_call_arg<'b: 'a, Ans: LookupAnswer>(
+        &self,
+        x: Option<&CallArg<'b>>,
+        solver: &AnswersSolver<Ans>,
+        errors: &ErrorCollector,
+    ) -> Option<CallArg<'a>> {
+        x.map(|x| self.call_arg(x, solver, errors))
+    }
+
+    pub fn vec_call_arg<'b: 'a, Ans: LookupAnswer>(
+        &self,
+        xs: &[CallArg<'b>],
+        solver: &AnswersSolver<Ans>,
+        errors: &ErrorCollector,
+    ) -> Vec<CallArg<'a>> {
+        xs.map(|x| self.call_arg(x, solver, errors))
+    }
+
+    pub fn vec_call_keyword<'b: 'a, Ans: LookupAnswer>(
+        &self,
+        xs: &[CallKeyword<'b>],
+        solver: &AnswersSolver<Ans>,
+        errors: &ErrorCollector,
+    ) -> Vec<CallKeyword<'a>> {
+        xs.map(|x| self.call_keyword(x, solver, errors))
+    }
+}
+
 #[derive(Clone, Debug)]
 pub struct CallKeyword<'a> {
     pub range: TextRange,