pyrefly 0.20.0__tar.gz → 0.20.2__tar.gz

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

@@ -1841,11 +1841,10 @@ dependencies = [
 
 [[package]]
 name = "pyrefly"
-version = "0.20.0"
+version = "0.20.2"
 dependencies = [
  "anstream",
  "anyhow",
- "append-only-vec",
  "base64",
  "blake3",
  "clap",
@@ -1899,7 +1898,7 @@ dependencies = [
 
 [[package]]
 name = "pyrefly_derive"
-version = "0.20.0"
+version = "0.20.2"
 dependencies = [
  "proc-macro2",
  "quote",
@@ -1908,10 +1907,11 @@ dependencies = [
 
 [[package]]
 name = "pyrefly_util"
-version = "0.20.0"
+version = "0.20.2"
 dependencies = [
  "anstream",
  "anyhow",
+ "append-only-vec",
  "argfile",
  "bstr",
  "const-str",

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

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

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

@@ -2,7 +2,7 @@
 
 [package]
 name = "pyrefly"
-version = "0.20.0"
+version = "0.20.2"
 authors = ["Meta"]
 edition = "2024"
 repository = "https://github.com/facebook/pyrefly"
@@ -19,7 +19,6 @@ path = "bin/main.rs"
 [dependencies]
 anstream = "0.6.11"
 anyhow = "1.0.95"
-append-only-vec = "0.1.2"
 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"] }

{pyrefly-0.20.0 → pyrefly-0.20.2}/pyrefly/bin/main.rs

@@ -32,6 +32,7 @@ use library::run::LspArgs;
 use library::standard_config_finder;
 use path_absolutize::Absolutize;
 use pyrefly::library::library::library::library;
+use pyrefly::library::library::library::library::Severity;
 use pyrefly::library::library::library::library::finder::ConfigError;
 use pyrefly_util::arc_id::ArcId;
 use pyrefly_util::args::clap_env;
@@ -170,6 +171,18 @@ fn get_explicit_config(
     )
 }
 
+fn add_config_errors(config_finder: &ConfigFinder, errors: Vec<ConfigError>) -> anyhow::Result<()> {
+    if errors.iter().any(|e| e.severity() == Severity::Error) {
+        for e in errors {
+            e.print();
+        }
+        Err(anyhow::anyhow!("Fatal configuration error"))
+    } else {
+        config_finder.add_errors(errors);
+        Ok(())
+    }
+}
+
 /// Get inputs for a full-project check. We will look for a config file and type-check the project it defines.
 fn get_globs_and_config_for_project(
     config: Option<PathBuf>,
@@ -210,7 +223,7 @@ fn get_globs_and_config_for_project(
 
     // We want our config_finder to never actually
     let config_finder = ConfigFinder::new_constant(config.dupe());
-    config_finder.add_errors(errors);
+    add_config_errors(&config_finder, errors)?;
 
     debug!("Config is: {}", config);
 
@@ -227,15 +240,33 @@ fn get_globs_and_config_for_files(
 ) -> anyhow::Result<(FilteredGlobs, ConfigFinder)> {
     let project_excludes = project_excludes.unwrap_or_else(ConfigFile::default_project_excludes);
     let files_to_check = absolutize(files_to_check)?;
-    let config_finder = match config {
+    let (config_finder, errors) = match config {
         Some(explicit) => {
             let (config, errors) = get_explicit_config(&explicit, args);
             let config_finder = ConfigFinder::new_constant(config);
-            config_finder.add_errors(errors);
-            config_finder
+            (config_finder, errors)
+        }
+        None => {
+            let config_finder = config_finder(args.clone());
+            // If there is only one input and one root, we treat config parse errors as fatal,
+            // so that `pyrefly check .` exits immediately on an unparseable config, matching the
+            // behavior of `pyrefly check` (see get_globs_and_config_for_project).
+            let solo_root = if files_to_check.len() == 1 {
+                files_to_check.roots().first().cloned()
+            } else {
+                None
+            };
+            if let Some(root) = solo_root {
+                // We don't care about the contents of the config, only if we generated any errors while parsing it.
+                config_finder.directory(&root);
+                let errors = config_finder.errors();
+                (config_finder, errors)
+            } else {
+                (config_finder, Vec::new())
+            }
         }
-        None => config_finder(args.clone()),
     };
+    add_config_errors(&config_finder, errors)?;
     Ok((
         FilteredGlobs::new(files_to_check, project_excludes),
         config_finder,

{pyrefly-0.20.0 → pyrefly-0.20.2}/pyrefly/lib/alt/answers.rs

@@ -5,6 +5,7 @@
  * LICENSE file in the root directory of this source tree.
  */
 
+use std::cell::RefCell;
 use std::fmt;
 use std::fmt::Debug;
 use std::fmt::Display;
@@ -32,6 +33,7 @@ use crate::alt::attr::AttrDefinition;
 use crate::alt::attr::AttrInfo;
 use crate::alt::traits::Solve;
 use crate::alt::traits::SolveRecursive;
+use crate::binding::binding::AnyIdx;
 use crate::binding::binding::Binding;
 use crate::binding::binding::Exported;
 use crate::binding::binding::Key;
@@ -324,10 +326,41 @@ impl Solutions {
     }
 }
 
-#[derive(Clone)]
+/// Represent a stack of in-progress calculations in an `AnswersSolver`.
+///
+/// This is useful for debugging, particularly for debugging cycle handling.
+///
+/// The stack is per-thread; we create a new `AnswersSolver` every time
+/// we change modules when resolving exports, but the stack is passed
+/// down because cycles can cross module boundaries.
+pub struct CalculationStack(RefCell<Vec<(ModuleInfo, AnyIdx)>>);
+
+impl CalculationStack {
+    pub fn new() -> Self {
+        Self(RefCell::new(Vec::new()))
+    }
+
+    fn push(&self, module_info: ModuleInfo, idx: AnyIdx) {
+        self.0.borrow_mut().push((module_info, idx));
+    }
+
+    fn pop(&self) -> Option<(ModuleInfo, AnyIdx)> {
+        self.0.borrow_mut().pop()
+    }
+
+    pub fn peek(&self) -> Option<(ModuleInfo, AnyIdx)> {
+        self.0.borrow().last().cloned()
+    }
+
+    pub fn into_vec(&self) -> Vec<(ModuleInfo, AnyIdx)> {
+        self.0.borrow().clone()
+    }
+}
+
 pub struct AnswersSolver<'a, Ans: LookupAnswer> {
     answers: &'a Ans,
     current: &'a Answers,
+    stack: &'a CalculationStack,
     // The base solver is only used to reset the error collector at binding
     // boundaries. Answers code should generally use the error collector passed
     // along the call stack instead.
@@ -345,6 +378,7 @@ pub trait LookupAnswer: Sized {
         module: ModuleName,
         path: Option<&ModulePath>,
         k: &K,
+        stack: &CalculationStack,
     ) -> Arc<K::Answer>
     where
         AnswerTable: TableKeyed<K, Value = AnswerEntry<K>>,
@@ -442,6 +476,7 @@ impl Answers {
         let answers_solver = AnswersSolver {
             stdlib,
             answers,
+            stack: &CalculationStack::new(),
             bindings,
             base_errors: errors,
             exports,
@@ -509,6 +544,7 @@ impl Answers {
         stdlib: &Stdlib,
         uniques: &UniqueFactory,
         key: Hashed<&K>,
+        stack: &CalculationStack,
     ) -> Arc<K::Answer>
     where
         AnswerTable: TableKeyed<K, Value = AnswerEntry<K>>,
@@ -523,6 +559,7 @@ impl Answers {
             exports,
             recurser: &Recurser::new(),
             current: self,
+            stack,
         };
         let v = solver.get_hashed(key);
         let mut vv = (*v).clone();
@@ -592,6 +629,7 @@ impl<'a, Ans: LookupAnswer> AnswersSolver<'a, Ans> {
         uniques: &'a UniqueFactory,
         recurser: &'a Recurser<Var>,
         stdlib: &'a Stdlib,
+        stack: &'a CalculationStack,
     ) -> AnswersSolver<'a, Ans> {
         AnswersSolver {
             stdlib,
@@ -602,6 +640,7 @@ impl<'a, Ans: LookupAnswer> AnswersSolver<'a, Ans> {
             exports,
             recurser,
             current,
+            stack,
         }
     }
 
@@ -617,6 +656,10 @@ impl<'a, Ans: LookupAnswer> AnswersSolver<'a, Ans> {
         &self.current.solver
     }
 
+    pub fn stack(&self) -> &CalculationStack {
+        self.stack
+    }
+
     pub fn for_display(&self, t: Type) -> Type {
         self.solver().for_display(t)
     }
@@ -637,7 +680,7 @@ impl<'a, Ans: LookupAnswer> AnswersSolver<'a, Ans> {
         {
             self.get(k)
         } else {
-            self.answers.get(module, path, k)
+            self.answers.get(module, path, k, self.stack)
         }
     }
 
@@ -680,6 +723,8 @@ impl<'a, Ans: LookupAnswer> AnswersSolver<'a, Ans> {
         BindingTable: TableKeyed<K, Value = BindingEntry<K>>,
     {
         let calculation = self.get_calculation(idx);
+        self.stack
+            .push(self.module_info().dupe(), K::to_anyidx(idx));
         let result = calculation.calculate_with_recursive(
             || {
                 let binding = self.bindings().get(idx);
@@ -694,6 +739,7 @@ impl<'a, Ans: LookupAnswer> AnswersSolver<'a, Ans> {
             let k = self.bindings().idx_to_key(idx).range();
             K::record_recursive(self, k, v, r, self.base_errors);
         }
+        self.stack.pop();
         match result {
             Ok((v, _)) => v,
             Err(r) => Arc::new(K::promote_recursive(r)),

{pyrefly-0.20.0 → pyrefly-0.20.2}/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.2}/pyrefly/lib/alt/call.rs

@@ -5,10 +5,8 @@
  * LICENSE file in the root directory of this source tree.
  */
 
-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 +17,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 +650,14 @@ 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 call = CallWithTypes::new();
+        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() {