pyrefly 0.20.2__tar.gz → 0.21.0__tar.gz

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

@@ -157,9 +157,9 @@ dependencies = [
 
 [[package]]
 name = "anyhow"
-version = "1.0.95"
+version = "1.0.98"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "34ac096ce696dc2fcabef30516bb13c0a68a11d30131d3df6f04711467681b04"
+checksum = "e16d2d3311acee920a9eb8d33b8cbc1787ce4a264e85f964c2404b969bdcd487"
 
 [[package]]
 name = "append-only-vec"
@@ -892,6 +892,15 @@ dependencies = [
  "slab",
 ]
 
+[[package]]
+name = "fuzzy-matcher"
+version = "0.3.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "54614a3312934d066701a80f20f15fa3b56d67ac7722b39eea5b4c9dd1d66c94"
+dependencies = [
+ "thread_local",
+]
+
 [[package]]
 name = "fxhash"
 version = "0.2.1"
@@ -1330,6 +1339,16 @@ version = "0.2.172"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "d750af042f7ef4f724306de029d18836c26c1765a54a6a3f094cbd23a7267ffa"
 
+[[package]]
+name = "libmimalloc-sys"
+version = "0.1.42"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ec9d6fac27761dabcd4ee73571cdb06b7022dc99089acbe5435691edffaac0f4"
+dependencies = [
+ "cc",
+ "libc",
+]
+
 [[package]]
 name = "libredox"
 version = "0.1.3"
@@ -1454,6 +1473,15 @@ dependencies = [
  "windows-sys 0.52.0",
 ]
 
+[[package]]
+name = "mimalloc"
+version = "0.1.46"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "995942f432bbb4822a7e9c3faa87a695185b0d09273ba85f097b54f4e458f2af"
+dependencies = [
+ "libmimalloc-sys",
+]
+
 [[package]]
 name = "miniz_oxide"
 version = "0.6.2"
@@ -1841,7 +1869,7 @@ dependencies = [
 
 [[package]]
 name = "pyrefly"
-version = "0.20.2"
+version = "0.21.0"
 dependencies = [
  "anstream",
  "anyhow",
@@ -1854,10 +1882,12 @@ dependencies = [
  "dupe",
  "enum-iterator",
  "equivalent",
+ "fuzzy-matcher",
  "indicatif",
  "itertools 0.14.0",
  "lsp-server",
  "lsp-types",
+ "mimalloc",
  "num-bigint",
  "num-traits",
  "parse-display",
@@ -1898,7 +1928,7 @@ dependencies = [
 
 [[package]]
 name = "pyrefly_derive"
-version = "0.20.2"
+version = "0.21.0"
 dependencies = [
  "proc-macro2",
  "quote",
@@ -1907,7 +1937,7 @@ dependencies = [
 
 [[package]]
 name = "pyrefly_util"
-version = "0.20.2"
+version = "0.21.0"
 dependencies = [
  "anstream",
  "anyhow",

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

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

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

@@ -2,7 +2,7 @@
 
 [package]
 name = "pyrefly"
-version = "0.20.2"
+version = "0.21.0"
 authors = ["Meta"]
 edition = "2024"
 repository = "https://github.com/facebook/pyrefly"
@@ -18,7 +18,7 @@ path = "bin/main.rs"
 
 [dependencies]
 anstream = "0.6.11"
-anyhow = "1.0.95"
+anyhow = "1.0.98"
 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"] }
@@ -28,6 +28,7 @@ crossbeam-channel = "0.5.15"
 dupe = "0.9.1"
 enum-iterator = "1.4.1"
 equivalent = "1.0"
+fuzzy-matcher = "0.3.7"
 indicatif = { version = "0.17.6", features = ["futures", "improved_unicode", "rayon", "tokio"] }
 itertools = "0.14.0"
 lsp-server = "0.7.2"
@@ -82,5 +83,8 @@ zstd = { version = "0.13", features = ["experimental", "zstdmt"] }
 [target.'cfg(target_arch = "wasm32")'.dependencies]
 zstd = "0.13"
 
+[target.'cfg(target_os = "windows")'.dependencies]
+mimalloc = "0.1.46"
+
 [lints]
 rust = { unexpected_cfgs = { check-cfg = ["cfg(fbcode_build)"], level = "warn" } }

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

@@ -51,6 +51,10 @@ use tracing::info;
 #[cfg(all(any(target_os = "linux", target_os = "macos"), not(fbcode_build)))]
 static ALLOC: tikv_jemallocator::Jemalloc = tikv_jemallocator::Jemalloc;
 
+#[global_allocator]
+#[cfg(target_os = "windows")]
+static ALLOC: mimalloc::MiMalloc = mimalloc::MiMalloc;
+
 #[derive(Debug, Parser)]
 #[command(name = "pyrefly")]
 #[command(about = "Next generation of Pyre type checker", long_about = None)]

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

@@ -326,6 +326,17 @@ impl Solutions {
     }
 }
 
+/// Compactly represents the identity of a binding, for the purposes of
+/// understanding the calculation stack.
+#[derive(Debug, Clone, Dupe)]
+pub struct CalcId(pub Bindings, pub AnyIdx);
+
+impl PartialEq for CalcId {
+    fn eq(&self, other: &Self) -> bool {
+        (self.0.module_info(), &self.1) == (other.0.module_info(), &other.1)
+    }
+}
+
 /// Represent a stack of in-progress calculations in an `AnswersSolver`.
 ///
 /// This is useful for debugging, particularly for debugging cycle handling.
@@ -333,26 +344,26 @@ impl Solutions {
 /// 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)>>);
+pub struct CalcStack(RefCell<Vec<CalcId>>);
 
-impl CalculationStack {
+impl CalcStack {
     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 push(&self, bindings: Bindings, idx: AnyIdx) {
+        self.0.borrow_mut().push(CalcId(bindings, idx));
     }
 
-    fn pop(&self) -> Option<(ModuleInfo, AnyIdx)> {
+    fn pop(&self) -> Option<CalcId> {
         self.0.borrow_mut().pop()
     }
 
-    pub fn peek(&self) -> Option<(ModuleInfo, AnyIdx)> {
+    pub fn peek(&self) -> Option<CalcId> {
         self.0.borrow().last().cloned()
     }
 
-    pub fn into_vec(&self) -> Vec<(ModuleInfo, AnyIdx)> {
+    pub fn into_vec(&self) -> Vec<CalcId> {
         self.0.borrow().clone()
     }
 }
@@ -360,7 +371,7 @@ impl CalculationStack {
 pub struct AnswersSolver<'a, Ans: LookupAnswer> {
     answers: &'a Ans,
     current: &'a Answers,
-    stack: &'a CalculationStack,
+    stack: &'a CalcStack,
     // 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.
@@ -378,7 +389,7 @@ pub trait LookupAnswer: Sized {
         module: ModuleName,
         path: Option<&ModulePath>,
         k: &K,
-        stack: &CalculationStack,
+        stack: &CalcStack,
     ) -> Arc<K::Answer>
     where
         AnswerTable: TableKeyed<K, Value = AnswerEntry<K>>,
@@ -476,7 +487,7 @@ impl Answers {
         let answers_solver = AnswersSolver {
             stdlib,
             answers,
-            stack: &CalculationStack::new(),
+            stack: &CalcStack::new(),
             bindings,
             base_errors: errors,
             exports,
@@ -544,7 +555,7 @@ impl Answers {
         stdlib: &Stdlib,
         uniques: &UniqueFactory,
         key: Hashed<&K>,
-        stack: &CalculationStack,
+        stack: &CalcStack,
     ) -> Arc<K::Answer>
     where
         AnswerTable: TableKeyed<K, Value = AnswerEntry<K>>,
@@ -578,6 +589,10 @@ impl Answers {
         self.solver.for_display(t)
     }
 
+    pub fn solver(&self) -> &Solver {
+        &self.solver
+    }
+
     pub fn get_type_trace(&self, range: TextRange) -> Option<Arc<Type>> {
         let lock = self.trace.as_ref()?.lock();
         lock.types.get(&range).duped()
@@ -629,7 +644,7 @@ impl<'a, Ans: LookupAnswer> AnswersSolver<'a, Ans> {
         uniques: &'a UniqueFactory,
         recurser: &'a Recurser<Var>,
         stdlib: &'a Stdlib,
-        stack: &'a CalculationStack,
+        stack: &'a CalcStack,
     ) -> AnswersSolver<'a, Ans> {
         AnswersSolver {
             stdlib,
@@ -656,7 +671,7 @@ impl<'a, Ans: LookupAnswer> AnswersSolver<'a, Ans> {
         &self.current.solver
     }
 
-    pub fn stack(&self) -> &CalculationStack {
+    pub fn stack(&self) -> &CalcStack {
         self.stack
     }
 
@@ -723,8 +738,7 @@ 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));
+        self.stack.push(self.bindings().dupe(), K::to_anyidx(idx));
         let result = calculation.calculate_with_recursive(
             || {
                 let binding = self.bindings().get(idx);
@@ -948,9 +962,7 @@ impl<'a, Ans: LookupAnswer> AnswersSolver<'a, Ans> {
     pub fn error_swallower(&self) -> ErrorCollector {
         ErrorCollector::new(self.module_info().dupe(), ErrorStyle::Never)
     }
-}
 
-impl<'a, Ans: LookupAnswer> AnswersSolver<'a, Ans> {
     pub fn record_external_attribute_definition_index(
         &self,
         base: &Type,

{pyrefly-0.20.2 → pyrefly-0.21.0}/pyrefly/lib/alt/attr.rs

@@ -136,12 +136,16 @@ impl AttrSubsetError {
                     ", 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}`"
+                    "{got_desc}`{child_class}.{attr_name}` has type `{}`, which is not assignable to `{}`{want_desc}`{parent_class}.{attr_name}`",
+                    got.deterministic_printing(),
+                    want.deterministic_printing()
                 )
             }
             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)"
+                    "`{child_class}.{attr_name}` has type `{}`, which is not consistent with `{}` in `{parent_class}.{attr_name}` (the type of read-write attributes cannot be changed)",
+                    got.deterministic_printing(),
+                    want.deterministic_printing()
                 )
             }
             AttrSubsetError::Contravariant {
@@ -155,7 +159,9 @@ impl AttrSubsetError {
                     ""
                 };
                 format!(
-                    "{desc}`{child_class}.{attr_name}` has type `{got}`, which is not assignable from `{want}`, the property getter for `{parent_class}.{attr_name}`"
+                    "{desc}`{child_class}.{attr_name}` has type `{}`, which is not assignable from `{}`, the property getter for `{parent_class}.{attr_name}`",
+                    got.deterministic_printing(),
+                    want.deterministic_printing()
                 )
             }
         }
@@ -1297,9 +1303,9 @@ impl<'a, Ans: LookupAnswer> AnswersSolver<'a, Ans> {
     /// on the metaclass instead of class `A` (i.e. we are looking for `type.__magic_dunder_attr__`
     /// instead of `A.__magic_dunder_attr__`).
     fn lookup_magic_dunder_attr(&self, base: AttributeBase, dunder_name: &Name) -> LookupResult {
-        match base {
+        match &base {
             AttributeBase::ClassObject(class) => {
-                let metadata = self.get_metadata_for_class(&class);
+                let metadata = self.get_metadata_for_class(class);
                 let metaclass = metadata.metaclass().unwrap_or(self.stdlib.builtins_type());
                 match self.get_instance_attribute(metaclass, dunder_name) {
                     Some(attr) => LookupResult::Found(attr),
@@ -1308,7 +1314,16 @@ impl<'a, Ans: LookupAnswer> AnswersSolver<'a, Ans> {
                     )),
                 }
             }
-            base => self.lookup_attr_from_attribute_base(base, dunder_name),
+            AttributeBase::ClassInstance(cls)
+            | AttributeBase::EnumLiteral(cls, _, _)
+            | AttributeBase::TypeVar(_, Some(cls))
+                if (*dunder_name == dunder::SETATTR || *dunder_name == dunder::DELATTR)
+                    && self.method_is_inherited_from_object(cls, dunder_name) =>
+            {
+                LookupResult::NotFound(NotFound::Attribute(cls.class_object().clone()))
+            }
+
+            _ => self.lookup_attr_from_attribute_base(base, dunder_name),
         }
     }
 
@@ -1494,7 +1509,8 @@ impl<'a, Ans: LookupAnswer> AnswersSolver<'a, Ans> {
                 Some(AttributeBase::ClassObject(class.class_object().dupe()))
             }
             Type::Type(box Type::Quantified(q)) if q.is_type_var() => match q.restriction() {
-                // TODO(#119): this is wrong, because we lose the information that this is a type var
+                // TODO(https://github.com/facebook/pyrefly/issues/514)
+                // this is wrong, because we lose the information that this is a type var
                 Restriction::Bound(bound) => {
                     self.as_attribute_base_no_union(Type::type_form(bound.clone()))
                 }
@@ -1553,15 +1569,6 @@ impl<'a, Ans: LookupAnswer> AnswersSolver<'a, Ans> {
                 }
             }
             Type::SuperInstance(box (cls, obj)) => Some(AttributeBase::SuperInstance(cls, obj)),
-            Type::Quantified(q) if q.is_type_var() => match q.restriction() {
-                // TODO(#119): this is wrong, because we lose the information that this is a type var
-                Restriction::Bound(bound) => self.as_attribute_base_no_union(bound.clone()),
-                // TODO: handle constraints
-                Restriction::Constraints(_) => None,
-                Restriction::Unrestricted => {
-                    Some(AttributeBase::ClassInstance(self.stdlib.object().clone()))
-                }
-            },
             // TODO: check to see which ones should have class representations
             Type::Union(_)
             | Type::SpecialForm(_)

{pyrefly-0.20.2 → pyrefly-0.21.0}/pyrefly/lib/alt/call.rs

@@ -207,6 +207,8 @@ impl<'a, Ans: LookupAnswer> AnswersSolver<'a, Ans> {
             Type::Type(box Type::TypedDict(typed_dict)) => {
                 Some(CallTarget::new(Target::TypedDict(typed_dict)))
             }
+            // TODO: this is wrong, because we lose the information that this is a type variable
+            // TODO: handle type[T]
             Type::Quantified(q) if q.is_type_var() => match q.restriction() {
                 Restriction::Bound(bound) => self.as_call_target(bound.clone()),
                 // TODO: handle constraints
@@ -575,7 +577,9 @@ impl<'a, Ans: LookupAnswer> AnswersSolver<'a, Ans> {
                 };
                 let self_obj = match first_arg_type {
                     Some(Type::Type(box Type::ClassType(c))) => Some(c.to_type()),
-                    Some(Type::ClassDef(class)) => Some(class.as_class_type().to_type()),
+                    Some(Type::ClassDef(class)) => {
+                        Some(self.as_class_type_unchecked(&class).to_type())
+                    }
                     _ => None,
                 };
                 if let Some(self_obj) = self_obj {

{pyrefly-0.20.2 → pyrefly-0.21.0}/pyrefly/lib/alt/class/class_field.rs

@@ -50,8 +50,6 @@ use crate::types::callable::Param;
 use crate::types::callable::Required;
 use crate::types::class::Class;
 use crate::types::class::ClassType;
-use crate::types::class::Substitution;
-use crate::types::class::TArgs;
 use crate::types::literal::Lit;
 use crate::types::quantified::Quantified;
 use crate::types::typed_dict::TypedDict;
@@ -63,7 +61,9 @@ use crate::types::types::Forall;
 use crate::types::types::Forallable;
 use crate::types::types::Overload;
 use crate::types::types::OverloadType;
+use crate::types::types::Substitution;
 use crate::types::types::SuperObj;
+use crate::types::types::TArgs;
 use crate::types::types::Type;
 
 /// Correctly analyzing which attributes are visible on class objects, as well
@@ -123,7 +123,7 @@ impl Display for ClassField {
         match &self.0 {
             ClassFieldInner::Simple {
                 ty, initialization, ..
-            } => write!(f, "@{ty} ({initialization})"),
+            } => write!(f, "{ty} ({initialization})"),
         }
     }
 }
@@ -259,7 +259,7 @@ impl ClassField {
         match &self.0 {
             ClassFieldInner::Simple { ty, .. } => ty.collect_quantifieds(&mut qs),
         };
-        tparams.quantified().any(|q| qs.contains(q))
+        tparams.quantifieds().any(|q| qs.contains(q))
     }
 
     fn as_raw_special_method_type(self, instance: &Instance) -> Option<Type> {
@@ -794,6 +794,13 @@ impl<'a, Ans: LookupAnswer> AnswersSolver<'a, Ans> {
             _ => {}
         };
 
+        // Pin any vars in the type: leaking a var in a class field is particularly
+        // likely to lead to data races where downstream uses can pin inconsistently.
+        //
+        // TODO(stroxler): Ideally we would implement some simple heuristics, similar to
+        // first-use based inference we use with assignments, to get more useful types here.
+        let ty = self.solver().deep_force(ty);
+
         // Create the resulting field and check for override inconsistencies before returning
         let class_field = ClassField::new(
             ty,
@@ -1006,7 +1013,7 @@ impl<'a, Ans: LookupAnswer> AnswersSolver<'a, Ans> {
                 )
             }
             ClassFieldInner::Simple {
-                ty,
+                mut ty,
                 readonly,
                 annotation,
                 ..
@@ -1014,6 +1021,7 @@ impl<'a, Ans: LookupAnswer> AnswersSolver<'a, Ans> {
                 let is_class_var = annotation.is_some_and(|ann| ann.is_class_var());
                 match field.initialization() {
                     ClassFieldInitialization::Class(_) => {
+                        self.expand_type_mut(&mut ty); // bind_instance matches on the type, so resolve it if we can
                         bind_instance_attribute(instance, ty, is_class_var, readonly)
                     }
                     ClassFieldInitialization::Instance(_) if readonly || is_class_var => {
@@ -1066,17 +1074,17 @@ impl<'a, Ans: LookupAnswer> AnswersSolver<'a, Ans> {
     ) -> Option<Attribute> {
         let mut foralled = match ty {
             Type::Function(func) => Type::Forall(Box::new(Forall {
-                tparams: cls.tparams().clone(),
+                tparams: self.class_tparams(cls),
                 body: Forallable::Function((**func).clone()),
             })),
             Type::Forall(box Forall {
                 tparams,
                 body: body @ Forallable::Function(_),
             }) => {
-                let mut new_tparams = tparams.clone();
+                let mut new_tparams = tparams.as_ref().clone();
                 new_tparams.extend(cls.tparams());
                 Type::Forall(Box::new(Forall {
-                    tparams: new_tparams,
+                    tparams: Arc::new(new_tparams),
                     body: body.clone(),
                 }))
             }
@@ -1086,17 +1094,17 @@ impl<'a, Ans: LookupAnswer> AnswersSolver<'a, Ans> {
             }) => {
                 let new_signatures = signatures.clone().mapped(|sig| match sig {
                     OverloadType::Callable(callable) => OverloadType::Forall(Forall {
-                        tparams: cls.tparams().clone(),
+                        tparams: self.class_tparams(cls),
                         body: Function {
                             signature: callable,
                             metadata: (**metadata).clone(),
                         },
                     }),
                     OverloadType::Forall(Forall { tparams, body }) => {
-                        let mut new_tparams = tparams.clone();
+                        let mut new_tparams = tparams.as_ref().clone();
                         new_tparams.extend(cls.tparams());
                         OverloadType::Forall(Forall {
-                            tparams: new_tparams,
+                            tparams: Arc::new(new_tparams),
                             body,
                         })
                     }
@@ -1196,7 +1204,7 @@ impl<'a, Ans: LookupAnswer> AnswersSolver<'a, Ans> {
                 // Optimisation: Only compute the `got_attr` once, and only if we actually need it.
                 got_attr = Some(self.as_instance_attribute(
                     class_field,
-                    &Instance::of_class(&class.as_class_type()),
+                    &Instance::of_class(&self.as_class_type_unchecked(class)),
                 ));
             }
             let attr_check =
@@ -1391,6 +1399,14 @@ impl<'a, Ans: LookupAnswer> AnswersSolver<'a, Ans> {
             .map(|member| self.as_class_attribute(Arc::unwrap_or_clone(member.value), cls))
     }
 
+    pub fn method_is_inherited_from_object(&self, cls: &ClassType, name: &Name) -> bool {
+        let member = self.get_class_member(cls.class_object(), name);
+        match member {
+            Some(member) => member.defined_on("builtins", "object"),
+            None => false,
+        }
+    }
+
     /// Get the class's `__new__` method.
     ///
     /// This lookup skips normal method binding logic (it behaves like a cross