Add a flag to ClassFieldInitialization::Instance indicating whether the instance field must have been intialized or not

Summary:
Currently, if a field declared on class toplevel is not initialized immediately on the class toplevel, we always assume that it must never have been initialized. E.g.
```
class Foo:
  x: int

Foo.x  # ERROR! This is banned because `x` must have never been initialized
```
But there are several cases where this assumption is too wide-sweeping. For example, when `x` is annotated as `ClassVar[int]`, or when `Foo` is defined in stub files (see D74035159), it's actually more desirable if we assume `x` is "magically initialized" somehow and avoid reporting errors on `Foo.x`.

This diff proposes we attach a small piece of data to `ClassFieldInitialization::Instance` indicating whether we should consider `x` to be "magically initialized", to make it possible to suppress relevant errors by default. Only the data is added in this diff -- no logic is reading from the data yet. We'll be adding downstream readers of the data in D74035159

Reviewed By: rchen152

Differential Revision: D74035160

fbshipit-source-id: e58a2f60208ccd7b7d5ca2e6d1b142f43c0a420f

Author: grievejia

pyrefly/lib/alt/class/class_field.rs

@@ -69,14 +69,16 @@ pub enum ClassFieldInitialization {
     /// If this is a dataclass field, BoolKeywords stores the field's dataclass
     /// flags (which are boolean options that control how fields behave).
     Class(Option<BoolKeywords>),
-    Instance,
+    /// The boolean indicates whether we know the field may have been initialized
+    /// outside of the class body or not.
+    Instance(bool),
 }
 
 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::Instance(_) => write!(f, "not initialized in body"),
         }
     }
 }
@@ -232,7 +234,7 @@ impl ClassField {
         match self.instantiate_for(instance).0 {
             ClassFieldInner::Simple { ty, .. } => match self.initialization() {
                 ClassFieldInitialization::Class(_) => Some(ty),
-                ClassFieldInitialization::Instance => None,
+                ClassFieldInitialization::Instance(_) => None,
             },
         }
     }
@@ -255,7 +257,7 @@ impl ClassField {
                 ..
             } => Required::Optional,
             ClassFieldInner::Simple {
-                initialization: ClassFieldInitialization::Instance,
+                initialization: ClassFieldInitialization::Instance(_),
                 ..
             } => Required::Required,
         }
@@ -346,7 +348,7 @@ impl ClassField {
                         kws.set(DataclassKeywords::DEFAULT.0, true);
                         kws
                     }
-                    ClassFieldInitialization::Instance => BoolKeywords::new(),
+                    ClassFieldInitialization::Instance(_) => BoolKeywords::new(),
                 };
                 if kw_only {
                     flags.set(DataclassKeywords::KW_ONLY.0, true);
@@ -743,7 +745,7 @@ impl<'a, Ans: LookupAnswer> AnswersSolver<'a, Ans> {
         initial_value: &ClassFieldInitialValue,
     ) -> ClassFieldInitialization {
         match initial_value {
-            ClassFieldInitialValue::Instance(_) => ClassFieldInitialization::Instance,
+            ClassFieldInitialValue::Instance(_) => ClassFieldInitialization::Instance(false),
             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.
@@ -892,10 +894,10 @@ impl<'a, Ans: LookupAnswer> AnswersSolver<'a, Ans> {
                     ClassFieldInitialization::Class(_) => {
                         bind_instance_attribute(instance, ty, is_class_var, readonly)
                     }
-                    ClassFieldInitialization::Instance if readonly || is_class_var => {
+                    ClassFieldInitialization::Instance(_) if readonly || is_class_var => {
                         Attribute::read_only(ty)
                     }
-                    ClassFieldInitialization::Instance => Attribute::read_write(ty),
+                    ClassFieldInitialization::Instance(_) => Attribute::read_write(ty),
                 }
             }
         }
@@ -917,7 +919,7 @@ impl<'a, Ans: LookupAnswer> AnswersSolver<'a, Ans> {
                 )
             }
             ClassFieldInner::Simple {
-                initialization: ClassFieldInitialization::Instance,
+                initialization: ClassFieldInitialization::Instance(_),
                 annotation,
                 ..
             } if annotation

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 *initialization == ClassFieldInitialization::Instance {
+        if matches!(*initialization, ClassFieldInitialization::Instance(_)) {
             return false;
         }
         match ty {