pyrefly 0.22.2__tar.gz → 0.23.1__tar.gz

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

@@ -1872,7 +1872,7 @@ dependencies = [
 
 [[package]]
 name = "pyrefly"
-version = "0.22.2"
+version = "0.23.1"
 dependencies = [
  "anstream",
  "anyhow",
@@ -1930,7 +1930,7 @@ dependencies = [
 
 [[package]]
 name = "pyrefly_derive"
-version = "0.22.2"
+version = "0.23.1"
 dependencies = [
  "proc-macro2",
  "quote",
@@ -1939,7 +1939,7 @@ dependencies = [
 
 [[package]]
 name = "pyrefly_python"
-version = "0.22.2"
+version = "0.23.1"
 dependencies = [
  "anyhow",
  "dupe",
@@ -1953,6 +1953,7 @@ dependencies = [
  "ruff_python_parser",
  "ruff_text_size",
  "serde",
+ "starlark_map",
  "static_interner",
  "thiserror 2.0.12",
  "toml",
@@ -1960,7 +1961,7 @@ dependencies = [
 
 [[package]]
 name = "pyrefly_util"
-version = "0.22.2"
+version = "0.23.1"
 dependencies = [
  "anstream",
  "anyhow",
@@ -2172,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.22.2 → pyrefly-0.23.1}/PKG-INFO

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

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

@@ -2,7 +2,7 @@
 
 [package]
 name = "pyrefly_python"
-version = "0.22.2"
+version = "0.23.1"
 authors = ["Meta"]
 edition = "2024"
 repository = "https://github.com/facebook/pyrefly"
@@ -21,6 +21,7 @@ ruff_python_ast = { git = "https://github.com/astral-sh/ruff/", rev = "6e785867c
 ruff_python_parser = { git = "https://github.com/astral-sh/ruff/", rev = "6e785867c3a97691972e8a49c372b3effba90032" }
 ruff_text_size = { git = "https://github.com/astral-sh/ruff/", rev = "6e785867c3a97691972e8a49c372b3effba90032" }
 serde = { version = "1.0.185", features = ["derive", "rc"] }
+starlark_map = "0.13.0"
 static_interner = "0.1.1"
 thiserror = "2.0.12"
 

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

@@ -11,6 +11,7 @@ use ruff_python_ast::name::Name;
 pub const AENTER: Name = Name::new_static("__aenter__");
 pub const AEXIT: Name = Name::new_static("__aexit__");
 pub const ALL: Name = Name::new_static("__all__");
+pub const BOOL: Name = Name::new_static("__bool__");
 pub const CALL: Name = Name::new_static("__call__");
 pub const CONTAINS: Name = Name::new_static("__contains__");
 pub const DATACLASS_FIELDS: Name = Name::new_static("__dataclass_fields__");
@@ -38,10 +39,11 @@ 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__");
-pub const BOOL: Name = Name::new_static("__bool__");
+pub const SLOTS: Name = Name::new_static("__slots__");
 
 pub const RICH_CMPS: &[Name] = &[LT, LE, EQ, NE, GT, GE];
 /// Rich comparison methods supplied by the `functools.total_ordering` decorator

{pyrefly-0.22.2 → pyrefly-0.23.1}/crates/pyrefly_python/src/lib.rs

@@ -21,6 +21,8 @@
 
 pub mod ast;
 pub mod dunder;
+pub mod ignore;
 pub mod module_name;
+pub mod module_path;
 pub mod symbol_kind;
 pub mod sys_info;

{pyrefly-0.22.2/pyrefly/lib/module → pyrefly-0.23.1/crates/pyrefly_python/src}/module_path.rs

@@ -12,12 +12,13 @@ use std::path::PathBuf;
 use std::sync::Arc;
 
 use dupe::Dupe;
-use pyrefly_python::dunder;
-use pyrefly_python::module_name::ModuleName;
 use pyrefly_util::with_hash::WithHash;
 use serde::Serialize;
 use serde::Serializer;
 
+use crate::dunder;
+use crate::module_name::ModuleName;
+
 #[derive(Debug, Clone, Dupe, Copy, PartialEq, Eq, Hash, Default)]
 pub enum ModuleStyle {
     /// .py - executable code.

{pyrefly-0.22.2 → pyrefly-0.23.1}/crates/pyrefly_python/src/sys_info.rs

@@ -226,18 +226,22 @@ impl SysInfo {
     }
 }
 
-#[derive(Debug, PartialEq, Eq, PartialOrd, Ord)]
+#[derive(Debug, PartialEq, PartialOrd)]
 enum Value {
     Tuple(Vec<Value>),
     String(String),
     Int(i64),
     Bool(bool),
+    /// I know what the value evaluates to when considered truthy, but not it's precise outcome.
+    /// We make sure below that it never compares equal to itself
+    Truthiness(bool),
 }
 
 impl Value {
     fn to_bool(&self) -> bool {
         match self {
             Value::Bool(x) => *x,
+            Value::Truthiness(x) => *x,
             Value::Int(x) => *x != 0,
             Value::String(x) => !x.is_empty(),
             Value::Tuple(x) => !x.is_empty(),
@@ -250,13 +254,14 @@ impl Value {
             (Value::String(_), Value::String(_)) => true,
             (Value::Int(_), Value::Int(_)) => true,
             (Value::Bool(_), Value::Bool(_)) => true,
+            (Value::Truthiness(_), Value::Truthiness(_)) => false, // We don't know if they are the same ype
             _ => false,
         }
     }
 
     fn compare(&self, op: CmpOp, other: &Value) -> Option<bool> {
         if !self.same_type(other) {
-            return None; // Someone got confused
+            return None; // Someone got confused, or we are working with Truthiness
         }
         Some(match op {
             CmpOp::Eq => self == other,
@@ -339,24 +344,34 @@ impl SysInfo {
             Expr::StringLiteral(x) => Some(Value::String(x.value.to_str().to_owned())),
             Expr::BoolOp(x) => match x.op {
                 BoolOp::And => {
-                    let mut last = Value::Bool(true);
+                    let mut res = Some(Value::Bool(true));
                     for x in &x.values {
-                        last = self.evaluate(x)?;
-                        if !last.to_bool() {
-                            break;
+                        match self.evaluate(x) {
+                            None => res = None,
+                            Some(x) => match (x.to_bool(), res.is_none()) {
+                                (false, false) => return Some(x),
+                                (false, true) => return Some(Value::Truthiness(false)),
+                                (true, false) => res = Some(x),
+                                (true, true) => res = None,
+                            },
                         }
                     }
-                    Some(last)
+                    res
                 }
                 BoolOp::Or => {
-                    let mut last = Value::Bool(false);
+                    let mut res = Some(Value::Bool(false));
                     for x in &x.values {
-                        last = self.evaluate(x)?;
-                        if last.to_bool() {
-                            break;
+                        match self.evaluate(x) {
+                            None => res = None,
+                            Some(x) => match (x.to_bool(), res.is_none()) {
+                                (false, false) => res = Some(x),
+                                (false, true) => res = None,
+                                (true, false) => return Some(x),
+                                (true, true) => return Some(Value::Truthiness(true)),
+                            },
                         }
                     }
-                    Some(last)
+                    res
                 }
             },
             Expr::UnaryOp(x) => match x.op {

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

@@ -2,7 +2,7 @@
 
 [package]
 name = "pyrefly"
-version = "0.22.2"
+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.22.2 → 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.22.2 → pyrefly-0.23.1}/pyrefly/lib/alt/answers.rs

@@ -14,6 +14,7 @@ use std::sync::Arc;
 use dupe::Dupe;
 use dupe::OptionDupedExt;
 use pyrefly_python::module_name::ModuleName;
+use pyrefly_python::module_path::ModulePath;
 use pyrefly_util::display::DisplayWith;
 use pyrefly_util::display::DisplayWithCtx;
 use pyrefly_util::gas::Gas;
@@ -47,7 +48,6 @@ use crate::graph::index::Idx;
 use crate::graph::index_map::IndexMap;
 use crate::module::module_info::ModuleInfo;
 use crate::module::module_info::TextRangeWithModuleInfo;
-use crate::module::module_path::ModulePath;
 use crate::solver::solver::Solver;
 use crate::state::ide::IntermediateDefinition;
 use crate::state::ide::key_to_intermediate_definition;

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

@@ -16,6 +16,7 @@ use dupe::Dupe;
 use dupe::IterDupedExt;
 use itertools::Either;
 use pyrefly_python::module_name::ModuleName;
+use pyrefly_python::module_path::ModulePath;
 use pyrefly_util::display::DisplayWithCtx;
 use pyrefly_util::display::commas_iter;
 use pyrefly_util::recurser::Recurser;
@@ -50,7 +51,6 @@ use crate::graph::calculation::Calculation;
 use crate::graph::calculation::ProposalResult;
 use crate::graph::index::Idx;
 use crate::module::module_info::ModuleInfo;
-use crate::module::module_path::ModulePath;
 use crate::solver::type_order::TypeOrder;
 use crate::types::class::Class;
 use crate::types::stdlib::Stdlib;
@@ -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.22.2 → 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.22.2 → 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.22.2 → pyrefly-0.23.1}/pyrefly/lib/alt/class/class_field.rs

@@ -43,7 +43,6 @@ use crate::types::annotation::Annotation;
 use crate::types::annotation::Qualifier;
 use crate::types::callable::FuncMetadata;
 use crate::types::callable::Function;
-use crate::types::callable::FunctionKind;
 use crate::types::callable::Param;
 use crate::types::callable::Required;
 use crate::types::class::Class;
@@ -58,7 +57,6 @@ use crate::types::typed_dict::TypedDict;
 use crate::types::typed_dict::TypedDictField;
 use crate::types::types::BoundMethod;
 use crate::types::types::BoundMethodType;
-use crate::types::types::CalleeKind;
 use crate::types::types::Forall;
 use crate::types::types::Forallable;
 use crate::types::types::Overload;
@@ -75,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")
+            }
         }
     }
 }
@@ -95,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.
@@ -110,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.
@@ -135,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>,
@@ -144,6 +170,7 @@ impl ClassField {
             ty,
             annotation,
             initialization,
+            defined_by,
             read_only_reason,
             descriptor_getter,
             descriptor_setter,
@@ -190,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,
@@ -202,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,
@@ -221,6 +250,7 @@ impl ClassField {
                 ty,
                 annotation,
                 initialization,
+                defined_by,
                 read_only_reason,
                 descriptor_getter,
                 descriptor_setter,
@@ -229,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()
@@ -258,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,
             },
         }
     }
@@ -281,7 +312,7 @@ impl ClassField {
                 ..
             } => Required::Optional,
             ClassFieldInner::Simple {
-                initialization: ClassFieldInitialization::Instance(_),
+                initialization: ClassFieldInitialization::Instance | ClassFieldInitialization::Magic,
                 ..
             } => Required::Required,
         }
@@ -428,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() {
@@ -438,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)]
@@ -774,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)
@@ -848,6 +896,7 @@ impl<'a, Ans: LookupAnswer> AnswersSolver<'a, Ans> {
             ty,
             direct_annotation.cloned(),
             initialization,
+            defined_by,
             read_only_reason,
             descriptor_getter,
             descriptor_setter,
@@ -910,12 +959,16 @@ 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)) => {
                 // If this field was created via a call to a dataclass field specifier, extract field flags from the call.
-                if metadata.dataclass_metadata().is_some()
+                if let Some(dm) = metadata.dataclass_metadata()
                     && let Expr::Call(ExprCall {
                         range: _,
                         func,
@@ -926,10 +979,10 @@ impl<'a, Ans: LookupAnswer> AnswersSolver<'a, Ans> {
                     // so we can ignore any errors encountered here.
                     let ignore_errors = self.error_swallower();
                     let func_ty = self.expr_infer(func, &ignore_errors);
-                    if matches!(
-                        func_ty.callee_kind(),
-                        Some(CalleeKind::Function(FunctionKind::DataclassField))
-                    ) {
+                    let func_kind = func_ty.callee_kind();
+                    if let Some(func_kind) = func_kind
+                        && dm.field_specifiers.contains(&func_kind)
+                    {
                         let mut map = TypeMap::new();
                         for kw in keywords {
                             if let Some(name) = &kw.arg {
@@ -972,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)
@@ -1077,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)
+                    }
                 }
             }
         }
@@ -1107,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, .. } => {