pyrefly 0.23.0__tar.gz → 0.23.1__tar.gz

{pyrefly-0.23.0 → pyrefly-0.23.1}/Cargo.lock

@@ -1872,7 +1872,7 @@ dependencies = [
 
 [[package]]
 name = "pyrefly"
-version = "0.23.0"
+version = "0.23.1"
 dependencies = [
  "anstream",
  "anyhow",
@@ -1930,7 +1930,7 @@ dependencies = [
 
 [[package]]
 name = "pyrefly_derive"
-version = "0.23.0"
+version = "0.23.1"
 dependencies = [
  "proc-macro2",
  "quote",
@@ -1939,7 +1939,7 @@ dependencies = [
 
 [[package]]
 name = "pyrefly_python"
-version = "0.23.0"
+version = "0.23.1"
 dependencies = [
  "anyhow",
  "dupe",
@@ -1961,7 +1961,7 @@ dependencies = [
 
 [[package]]
 name = "pyrefly_util"
-version = "0.23.0"
+version = "0.23.1"
 dependencies = [
  "anstream",
  "anyhow",
@@ -2173,7 +2173,7 @@ checksum = "ba39f3699c378cd8970968dcbff9c43159ea4cfbd88d43c00b22f2ef10a435d2"
 [[package]]
 name = "ruff_annotate_snippets"
 version = "0.1.0"
-source = "git+https://github.com/astral-sh/ruff/?rev=6e785867c3a97691972e8a49c372b3effba90032#6e785867c3a97691972e8a49c372b3effba90032"
+source = "git+https://github.com/astral-sh/ruff/?rev=9bee8376a17401f9736b45fdefffb62edc2f1668#9bee8376a17401f9736b45fdefffb62edc2f1668"
 dependencies = [
  "anstyle",
  "memchr",

{pyrefly-0.23.0 → pyrefly-0.23.1}/PKG-INFO

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

{pyrefly-0.23.0 → pyrefly-0.23.1}/crates/pyrefly_python/Cargo.toml

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

{pyrefly-0.23.0 → pyrefly-0.23.1}/crates/pyrefly_python/src/dunder.rs

@@ -39,6 +39,7 @@ pub const NEG: Name = Name::new_static("__neg__");
 pub const NEW: Name = Name::new_static("__new__");
 pub const NEXT: Name = Name::new_static("__next__");
 pub const POS: Name = Name::new_static("__pos__");
+pub const POST_INIT: Name = Name::new_static("__post_init__");
 pub const SET: Name = Name::new_static("__set__");
 pub const SETATTR: Name = Name::new_static("__setattr__");
 pub const SETITEM: Name = Name::new_static("__setitem__");

{pyrefly-0.23.0 → pyrefly-0.23.1}/pyrefly/Cargo.toml

@@ -2,7 +2,7 @@
 
 [package]
 name = "pyrefly"
-version = "0.23.0"
+version = "0.23.1"
 authors = ["Meta"]
 edition = "2024"
 repository = "https://github.com/facebook/pyrefly"
@@ -42,7 +42,7 @@ pyrefly_python = { path = "../crates/pyrefly_python" }
 pyrefly_util = { path = "../pyrefly_util" }
 regex = "1.11.1"
 regex-syntax = "0.7.5"
-ruff_annotate_snippets = { git = "https://github.com/astral-sh/ruff/", rev = "6e785867c3a97691972e8a49c372b3effba90032" }
+ruff_annotate_snippets = { git = "https://github.com/astral-sh/ruff/", rev = "9bee8376a17401f9736b45fdefffb62edc2f1668" }
 ruff_python_ast = { git = "https://github.com/astral-sh/ruff/", rev = "6e785867c3a97691972e8a49c372b3effba90032" }
 ruff_python_parser = { git = "https://github.com/astral-sh/ruff/", rev = "6e785867c3a97691972e8a49c372b3effba90032" }
 ruff_source_file = { git = "https://github.com/astral-sh/ruff/", rev = "6e785867c3a97691972e8a49c372b3effba90032" }

{pyrefly-0.23.0 → pyrefly-0.23.1}/pyrefly/bin/main.rs

@@ -107,6 +107,7 @@ enum Command {
     /// Start an LSP server
     Lsp(LspArgs),
 
+    // Automatically add type annotations to a file or directory
     Autotype(FullCheckArgs),
 }
 
@@ -218,6 +219,7 @@ async fn run_command(command: Command, allow_forget: bool) -> anyhow::Result<Com
                         println!("Configuration at `{}`", path.display());
                     }
                 }
+                println!("  Using interpreter: {}", config.interpreters);
                 println!("  Covered files:");
                 for (i, fi) in files.iter().enumerate() {
                     if i < 10 {

{pyrefly-0.23.0 → pyrefly-0.23.1}/pyrefly/lib/alt/answers_solver.rs

@@ -322,7 +322,7 @@ impl Cycles {
         self.0.borrow().is_empty()
     }
 
-    // Handle a cycle we just detected.
+    /// Handle a cycle we just detected.
     ///
     /// Return whether or not to break immediately (which is relatively
     /// common, since we break on the minimal idx which is often where we would
@@ -555,7 +555,17 @@ impl<'a, Ans: LookupAnswer> AnswersSolver<'a, Ans> {
         // we need to record the placeholder => final answer correspondance.
         if let Some(r) = rec {
             let k = self.bindings().idx_to_key(idx).range();
+            // Always force recursive Vars as soon as we produce the final answer. This limits
+            // nondeterminism by ensuring that nothing downstream of the cycle can pin the type
+            // once the cycle has finished (although there can still be data races where the
+            // Var excapes the cycle in another thread before it has finished computing).
+            //
+            // `Var::ZERO` is just a dummy value used by a few of the `K: Solve`
+            // implementations that doen't actually use the Var, so we have to skip it.
             K::record_recursive(self, k, &v, r, self.base_errors);
+            if r != Var::ZERO {
+                self.solver().force_var(r);
+            }
         }
         // Handle cycle unwinding, if applicable.
         //

{pyrefly-0.23.0 → pyrefly-0.23.1}/pyrefly/lib/alt/attr.rs

@@ -1603,7 +1603,9 @@ impl<'a, Ans: LookupAnswer> AnswersSolver<'a, Ans> {
             Type::Type(box Type::Quantified(q)) => Some(AttributeBase::TypeVar(q, None)),
             Type::Type(box Type::Any(style)) => Some(AttributeBase::TypeAny(style)),
             Type::Module(module) => Some(AttributeBase::Module(module)),
-            Type::TypeVar(_) => Some(AttributeBase::ClassInstance(self.stdlib.type_var().clone())),
+            Type::TypeVar(_) | Type::Type(box Type::TypeVar(_)) => {
+                Some(AttributeBase::ClassInstance(self.stdlib.type_var().clone()))
+            }
             Type::ParamSpec(_) => Some(AttributeBase::ClassInstance(
                 self.stdlib.param_spec().clone(),
             )),

{pyrefly-0.23.0 → pyrefly-0.23.1}/pyrefly/lib/alt/call.rs

@@ -198,6 +198,7 @@ impl<'a, Ans: LookupAnswer> AnswersSolver<'a, Ans> {
                     ret: Type::Quantified(quantified),
                 })))
             }
+            Type::Type(box Type::Any(style)) => Some(CallTarget::new(Target::Any(style))),
             Type::Forall(forall) => {
                 let (qs, t) = self.solver().fresh_quantified(
                     &forall.tparams,

{pyrefly-0.23.0 → pyrefly-0.23.1}/pyrefly/lib/alt/class/class_field.rs

@@ -73,16 +73,21 @@ pub enum ClassFieldInitialization {
     /// If this is a dataclass field, DataclassFieldKeywords stores the field's
     /// dataclass flags (which are options that control how fields behave).
     Class(Option<DataclassFieldKeywords>),
-    /// The boolean indicates whether we know the field may have been initialized
-    /// outside of the class body or not.
-    Instance(bool),
+    Instance,
+    /// The field is not initialized in the class body or any method in the class,
+    /// but we treat it as if it was initialized.
+    /// For example, any field defined in a stub file.
+    Magic,
 }
 
 impl Display for ClassFieldInitialization {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         match self {
-            Self::Class(_) => write!(f, "initialized in body"),
-            Self::Instance(_) => write!(f, "not initialized in body"),
+            Self::Class(_) => write!(f, "initialized on class body"),
+            Self::Instance => write!(f, "initialized on instances"),
+            Self::Magic => {
+                write!(f, "not initialized on class body/method")
+            }
         }
     }
 }
@@ -93,6 +98,27 @@ impl ClassFieldInitialization {
     }
 }
 
+#[derive(Clone, Debug, TypeEq, VisitMut, PartialEq, Eq)]
+pub enum ClassFieldDefinedBy {
+    ClassBody,
+    Method,
+}
+
+impl Display for ClassFieldDefinedBy {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        match self {
+            Self::ClassBody => write!(f, "defined by class body"),
+            Self::Method => write!(f, "defined by method"),
+        }
+    }
+}
+
+impl ClassFieldDefinedBy {
+    fn recursive() -> Self {
+        ClassFieldDefinedBy::ClassBody
+    }
+}
+
 /// Raw information about an attribute declared somewhere in a class. We need to
 /// know whether it is initialized in the class body in order to determine
 /// both visibility rules and whether method binding should be performed.
@@ -108,6 +134,7 @@ enum ClassFieldInner {
         ty: Type,
         annotation: Option<Annotation>,
         initialization: ClassFieldInitialization,
+        defined_by: ClassFieldDefinedBy,
         /// The reason this field is read-only. `None` indicates it is read-write.
         read_only_reason: Option<ReadOnlyReason>,
         // Descriptor getter method, if there is one. `None` indicates no getter.
@@ -133,6 +160,7 @@ impl ClassField {
         ty: Type,
         annotation: Option<Annotation>,
         initialization: ClassFieldInitialization,
+        defined_by: ClassFieldDefinedBy,
         read_only_reason: Option<ReadOnlyReason>,
         descriptor_getter: Option<Type>,
         descriptor_setter: Option<Type>,
@@ -142,6 +170,7 @@ impl ClassField {
             ty,
             annotation,
             initialization,
+            defined_by,
             read_only_reason,
             descriptor_getter,
             descriptor_setter,
@@ -188,6 +217,7 @@ impl ClassField {
             ty,
             annotation: None,
             initialization: ClassFieldInitialization::Class(None),
+            defined_by: ClassFieldDefinedBy::ClassBody,
             read_only_reason: None,
             descriptor_getter: None,
             descriptor_setter: None,
@@ -200,6 +230,7 @@ impl ClassField {
             ty: Type::any_implicit(),
             annotation: None,
             initialization: ClassFieldInitialization::recursive(),
+            defined_by: ClassFieldDefinedBy::recursive(),
             read_only_reason: None,
             descriptor_getter: None,
             descriptor_setter: None,
@@ -219,6 +250,7 @@ impl ClassField {
                 ty,
                 annotation,
                 initialization,
+                defined_by,
                 read_only_reason,
                 descriptor_getter,
                 descriptor_setter,
@@ -227,6 +259,7 @@ impl ClassField {
                 ty: instance.instantiate_member(ty.clone()),
                 annotation: annotation.clone(),
                 initialization: initialization.clone(),
+                defined_by: defined_by.clone(),
                 read_only_reason: read_only_reason.clone(),
                 descriptor_getter: descriptor_getter
                     .as_ref()
@@ -256,7 +289,7 @@ impl ClassField {
         match self.instantiate_for(instance).0 {
             ClassFieldInner::Simple { ty, .. } => match self.initialization() {
                 ClassFieldInitialization::Class(_) => Some(ty),
-                ClassFieldInitialization::Instance(_) => None,
+                ClassFieldInitialization::Instance | ClassFieldInitialization::Magic => None,
             },
         }
     }
@@ -279,7 +312,7 @@ impl ClassField {
                 ..
             } => Required::Optional,
             ClassFieldInner::Simple {
-                initialization: ClassFieldInitialization::Instance(_),
+                initialization: ClassFieldInitialization::Instance | ClassFieldInitialization::Magic,
                 ..
             } => Required::Required,
         }
@@ -426,7 +459,9 @@ impl ClassField {
                         kws.default = true;
                         kws
                     }
-                    ClassFieldInitialization::Instance(_) => DataclassFieldKeywords::new(),
+                    ClassFieldInitialization::Instance | ClassFieldInitialization::Magic => {
+                        DataclassFieldKeywords::new()
+                    }
                 };
                 // If kw_only hasn't been explicitly set to false on the field, set it to true
                 if kw_only && flags.kw_only.is_none() {
@@ -436,6 +471,15 @@ impl ClassField {
             }
         }
     }
+
+    pub fn is_defined_on_class_body(&self) -> bool {
+        match &self.0 {
+            ClassFieldInner::Simple { defined_by, .. } => match defined_by {
+                ClassFieldDefinedBy::ClassBody => true,
+                ClassFieldDefinedBy::Method => false,
+            },
+        }
+    }
 }
 
 #[derive(Clone, PartialEq, Eq)]
@@ -772,6 +816,12 @@ impl<'a, Ans: LookupAnswer> AnswersSolver<'a, Ans> {
                     errors,
                 ),
         };
+        let defined_by = match initial_value {
+            ClassFieldInitialValue::Class(_) | ClassFieldInitialValue::Instance(None) => {
+                ClassFieldDefinedBy::ClassBody
+            }
+            ClassFieldInitialValue::Instance(Some(_)) => ClassFieldDefinedBy::Method,
+        };
 
         // Enum handling:
         // - Check whether the field is a member (which depends only on its type and name)
@@ -846,6 +896,7 @@ impl<'a, Ans: LookupAnswer> AnswersSolver<'a, Ans> {
             ty,
             direct_annotation.cloned(),
             initialization,
+            defined_by,
             read_only_reason,
             descriptor_getter,
             descriptor_setter,
@@ -908,7 +959,11 @@ impl<'a, Ans: LookupAnswer> AnswersSolver<'a, Ans> {
     ) -> ClassFieldInitialization {
         match initial_value {
             ClassFieldInitialValue::Instance(_) => {
-                ClassFieldInitialization::Instance(magically_initialized)
+                if magically_initialized {
+                    ClassFieldInitialization::Magic
+                } else {
+                    ClassFieldInitialization::Instance
+                }
             }
             ClassFieldInitialValue::Class(None) => ClassFieldInitialization::Class(None),
             ClassFieldInitialValue::Class(Some(e)) => {
@@ -970,6 +1025,7 @@ impl<'a, Ans: LookupAnswer> AnswersSolver<'a, Ans> {
         if field.is_dataclass_kwonly_marker() {
             DataclassMember::KwOnlyMarker
         } else if field.is_class_var()
+            || !field.is_defined_on_class_body()
             || (!field.has_explicit_annotation()
                 && self
                     .get_inherited_annotation(cls, name)
@@ -1075,15 +1131,19 @@ impl<'a, Ans: LookupAnswer> AnswersSolver<'a, Ans> {
                         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, read_only_reason)
                     }
-                    ClassFieldInitialization::Instance(_)
+                    ClassFieldInitialization::Instance | ClassFieldInitialization::Magic
                         if let Some(read_only_reason) = read_only_reason =>
                     {
                         Attribute::read_only(ty, read_only_reason)
                     }
-                    ClassFieldInitialization::Instance(_) if is_class_var => {
+                    ClassFieldInitialization::Instance | ClassFieldInitialization::Magic
+                        if is_class_var =>
+                    {
                         Attribute::read_only(ty, ReadOnlyReason::ClassVar)
                     }
-                    ClassFieldInitialization::Instance(_) => Attribute::read_write(ty),
+                    ClassFieldInitialization::Instance | ClassFieldInitialization::Magic => {
+                        Attribute::read_write(ty)
+                    }
                 }
             }
         }
@@ -1105,7 +1165,7 @@ impl<'a, Ans: LookupAnswer> AnswersSolver<'a, Ans> {
                 )
             }
             ClassFieldInner::Simple {
-                initialization: ClassFieldInitialization::Instance(false),
+                initialization: ClassFieldInitialization::Instance,
                 ..
             } => Attribute::no_access(NoAccessReason::ClassUseOfInstanceAttribute(cls.dupe())),
             ClassFieldInner::Simple { ty, .. } => {

{pyrefly-0.23.0 → pyrefly-0.23.1}/pyrefly/lib/alt/class/class_metadata.rs

@@ -357,10 +357,10 @@ impl<'a, Ans: LookupAnswer> AnswersSolver<'a, Ans> {
         let empty_tparams = self.get_class_tparams(cls).is_empty();
         if let Some(metaclass) = &metaclass {
             self.check_base_class_metaclasses(cls, metaclass, &base_metaclasses, errors);
-            if self.is_subset_eq(
-                &Type::ClassType(metaclass.clone()),
-                &Type::ClassType(self.stdlib.enum_meta().clone()),
-            ) {
+            if self
+                .as_superclass(metaclass, self.stdlib.enum_meta().class_object())
+                .is_some()
+            {
                 if !empty_tparams {
                     self.error(
                         errors,

{pyrefly-0.23.0 → pyrefly-0.23.1}/pyrefly/lib/alt/class/classdef.rs

@@ -127,6 +127,7 @@ impl<'a, Ans: LookupAnswer> AnswersSolver<'a, Ans> {
             // whether the argument is valid.
             Type::Type(box ty @ (Type::ClassType(_) | Type::Quantified(_))) => Some(ty.clone()),
             Type::Type(box Type::Tuple(_)) => Some(Type::any_tuple()),
+            Type::Type(box Type::Any(a)) => Some(a.propagate()),
             Type::None | Type::Type(box Type::None) => Some(Type::None),
             Type::ClassType(cls) if cls.is_builtin("type") => Some(Type::any_implicit()),
             Type::Any(_) => Some(ty.clone()),

{pyrefly-0.23.0 → pyrefly-0.23.1}/pyrefly/lib/alt/class/enums.rs

@@ -43,7 +43,7 @@ impl<'a, Ans: LookupAnswer> AnswersSolver<'a, Ans> {
             return false;
         }
         // Enum members must be initialized on the class
-        if matches!(*initialization, ClassFieldInitialization::Instance(_)) {
+        if !matches!(*initialization, ClassFieldInitialization::Class(_)) {
             return false;
         }
         match ty {

{pyrefly-0.23.0 → pyrefly-0.23.1}/pyrefly/lib/alt/narrow.rs

@@ -151,51 +151,91 @@ impl<'a, Ans: LookupAnswer> AnswersSolver<'a, Ans> {
     }
 
     fn narrow_isinstance(&self, left: &Type, right: &Type) -> Type {
-        if let Some(ts) = right.as_decomposed_tuple_or_union(self.stdlib) {
-            self.unions(ts.iter().map(|t| self.narrow_isinstance(left, t)).collect())
-        } else if let Some(right) = self.unwrap_class_object_silently(right) {
-            self.intersect_with_fallback(left, &right, || right.clone())
-        } else {
-            left.clone()
+        let mut res = Vec::new();
+        for right in self.as_class_info(right.clone()) {
+            if let Some(right) = self.unwrap_class_object_silently(&right) {
+                res.push(self.intersect_with_fallback(left, &right, || right.clone()))
+            } else {
+                res.push(left.clone());
+            }
         }
+        self.unions(res)
     }
 
     fn narrow_is_not_instance(&self, left: &Type, right: &Type) -> Type {
-        if let Some(ts) = right.as_decomposed_tuple_or_union(self.stdlib) {
-            self.intersects(&ts.map(|t| self.narrow_is_not_instance(left, t)))
-        } else if let Some(right) = self.unwrap_class_object_silently(right) {
-            self.subtract(left, &right)
-        } else {
-            left.clone()
+        let mut res = Vec::new();
+        for right in self.as_class_info(right.clone()) {
+            if let Some(right) = self.unwrap_class_object_silently(&right) {
+                res.push(self.subtract(left, &right))
+            } else {
+                res.push(left.clone())
+            }
         }
+        self.intersects(&res)
     }
 
     fn narrow_issubclass(&self, left: &Type, right: &Type, range: TextRange) -> Type {
-        if let Some(ts) = right.as_decomposed_tuple_or_union(self.stdlib) {
-            self.unions(
-                ts.iter()
-                    .map(|t| self.narrow_issubclass(left, t, range))
-                    .collect(),
-            )
-        } else if let Some(left) = self.untype_opt(left.clone(), range)
-            && let Some(right) = self.unwrap_class_object_silently(right)
-        {
-            Type::type_form(self.intersect(&left, &right))
-        } else {
-            left.clone()
+        let mut res = Vec::new();
+        for right in self.as_class_info(right.clone()) {
+            if let Some(left) = self.untype_opt(left.clone(), range)
+                && let Some(right) = self.unwrap_class_object_silently(&right)
+            {
+                res.push(Type::type_form(self.intersect(&left, &right)))
+            } else {
+                res.push(left.clone())
+            }
         }
+        self.unions(res)
     }
 
     fn narrow_is_not_subclass(&self, left: &Type, right: &Type, range: TextRange) -> Type {
-        if let Some(ts) = right.as_decomposed_tuple_or_union(self.stdlib) {
-            self.intersects(&ts.map(|t| self.narrow_is_not_subclass(left, t, range)))
-        } else if let Some(left) = self.untype_opt(left.clone(), range)
-            && let Some(right) = self.unwrap_class_object_silently(right)
-        {
-            Type::type_form(self.subtract(&left, &right))
-        } else {
-            left.clone()
+        let mut res = Vec::new();
+        for right in self.as_class_info(right.clone()) {
+            if let Some(left) = self.untype_opt(left.clone(), range)
+                && let Some(right) = self.unwrap_class_object_silently(&right)
+            {
+                res.push(Type::type_form(self.subtract(&left, &right)))
+            } else {
+                res.push(left.clone())
+            }
         }
+        self.intersects(&res)
+    }
+
+    fn narrow_length_greater(&self, ty: &Type, len: usize) -> Type {
+        self.distribute_over_union(ty, |ty| match ty {
+            Type::Tuple(Tuple::Concrete(elts)) if elts.len() <= len => Type::never(),
+            Type::ClassType(class)
+                if let Some(elements) = self.named_tuple_element_types(class)
+                    && elements.len() <= len =>
+            {
+                Type::never()
+            }
+            _ => ty.clone(),
+        })
+    }
+
+    fn narrow_length_less_than(&self, ty: &Type, len: usize) -> Type {
+        // TODO: simplify some tuple forms
+        // - unbounded tuples can be narrowed to empty tuple if len==1
+        // - unpacked tuples can be narrowed to concrete prefix+suffix if len==prefix.len()+suffix.len()+1
+        // this needs to be done in conjunction with https://github.com/facebook/pyrefly/issues/273
+        // otherwise the narrowed forms make weird unions when used with control flow
+        self.distribute_over_union(ty, |ty| match ty {
+            Type::Tuple(Tuple::Concrete(elts)) if elts.len() >= len => Type::never(),
+            Type::Tuple(Tuple::Unpacked(box (prefix, _, suffix)))
+                if prefix.len() + suffix.len() >= len =>
+            {
+                Type::never()
+            }
+            Type::ClassType(class)
+                if let Some(elements) = self.named_tuple_element_types(class)
+                    && elements.len() >= len =>
+            {
+                Type::never()
+            }
+            _ => ty.clone(),
+        })
     }
 
     pub fn atomic_narrow(
@@ -274,6 +314,52 @@ impl<'a, Ans: LookupAnswer> AnswersSolver<'a, Ans> {
                     _ => ty.clone(),
                 })
             }
+            AtomicNarrowOp::LenGt(v) => {
+                let right = self.expr_infer(v, errors);
+                let Type::Literal(Lit::Int(lit)) = &right else {
+                    return ty.clone();
+                };
+                let Some(len) = lit.as_i64().and_then(|i| i.to_usize()) else {
+                    return ty.clone();
+                };
+                self.narrow_length_greater(ty, len)
+            }
+            AtomicNarrowOp::LenGte(v) => {
+                let right = self.expr_infer(v, errors);
+                let Type::Literal(Lit::Int(lit)) = &right else {
+                    return ty.clone();
+                };
+                let Some(len) = lit.as_i64().and_then(|i| i.to_usize()) else {
+                    return ty.clone();
+                };
+                if len == 0 {
+                    return ty.clone();
+                }
+                self.narrow_length_greater(ty, len - 1)
+            }
+            AtomicNarrowOp::LenLt(v) => {
+                let right = self.expr_infer(v, errors);
+                let Type::Literal(Lit::Int(lit)) = &right else {
+                    return ty.clone();
+                };
+                let Some(len) = lit.as_i64().and_then(|i| i.to_usize()) else {
+                    return Type::never();
+                };
+                if len == 0 {
+                    return Type::never();
+                }
+                self.narrow_length_less_than(ty, len)
+            }
+            AtomicNarrowOp::LenLte(v) => {
+                let right = self.expr_infer(v, errors);
+                let Type::Literal(Lit::Int(lit)) = &right else {
+                    return ty.clone();
+                };
+                let Some(len) = lit.as_i64().and_then(|i| i.to_usize()) else {
+                    return ty.clone();
+                };
+                self.narrow_length_less_than(ty, len + 1)
+            }
             AtomicNarrowOp::In(v) => {
                 let exprs = match v {
                     Expr::List(list) => Some(list.elts.clone()),

{pyrefly-0.23.0 → pyrefly-0.23.1}/pyrefly/lib/alt/solve.rs

@@ -1131,11 +1131,9 @@ impl<'a, Ans: LookupAnswer> AnswersSolver<'a, Ans> {
             BindingExpect::TypeCheckExpr(x) => {
                 self.expr_infer(x, errors);
             }
-            BindingExpect::Bool(x, range) => {
-                // See test::attribute_narrow::test_invalid_narrows_on_bad_attribute_access for a
-                // test that fails if we do not discard the errors from expr_infer() here.
-                let ty = self.expr_infer(x, &self.error_swallower());
-                self.check_dunder_bool_is_callable(&ty, *range, errors);
+            BindingExpect::Bool(x) => {
+                let ty = self.expr_infer(x, errors);
+                self.check_dunder_bool_is_callable(&ty, x.range(), errors);
             }
             BindingExpect::Delete(x) => match x {
                 Expr::Name(_) => {
@@ -2935,8 +2933,7 @@ impl<'a, Ans: LookupAnswer> AnswersSolver<'a, Ans> {
         }
     }
 
-    pub fn untype_opt(&self, ty: Type, range: TextRange) -> Option<Type> {
-        let mut ty = ty;
+    pub fn untype_opt(&self, mut ty: Type, range: TextRange) -> Option<Type> {
         if let Type::Forall(forall) = ty {
             ty = self.promote_forall(*forall, range);
         };