Preserve literal member type in enums

Summary:
Instead of promoting away the enum member's literal type, we preserve the unpromoted literal & change VisitMut to skip it. Then, in alt/class/enums.rs we modify some logic to decide when to promote away the literal & when to keep it.

The special enum attr resolution is weirdly complex because it deals with a bunch of different conditions like django and mixins. I'm not a big fan of how complex it is but it seems necessary.

closes facebook#2741

Reviewed By: grievejia

Differential Revision: D96157102

fbshipit-source-id: 69ae410dc1afcec9e3a4c290f7724a6560bdb38f

Author: yangdanny97

conformance/third_party/conformance.exp

@@ -5075,39 +5075,6 @@
     }
   ],
   "enums_member_values.py": [
-    {
-      "code": -2,
-      "column": 12,
-      "concise_description": "assert_type(int, Literal[1]) failed",
-      "description": "assert_type(int, Literal[1]) failed",
-      "line": 21,
-      "name": "assert-type",
-      "severity": "error",
-      "stop_column": 43,
-      "stop_line": 21
-    },
-    {
-      "code": -2,
-      "column": 12,
-      "concise_description": "assert_type(int, Literal[1]) failed",
-      "description": "assert_type(int, Literal[1]) failed",
-      "line": 22,
-      "name": "assert-type",
-      "severity": "error",
-      "stop_column": 41,
-      "stop_line": 22
-    },
-    {
-      "code": -2,
-      "column": 16,
-      "concise_description": "assert_type(int, Literal[1, 3]) failed",
-      "description": "assert_type(int, Literal[1, 3]) failed",
-      "line": 26,
-      "name": "assert-type",
-      "severity": "error",
-      "stop_column": 50,
-      "stop_line": 26
-    },
     {
       "code": -2,
       "column": 16,
@@ -5144,8 +5111,8 @@
     {
       "code": -2,
       "column": 5,
-      "concise_description": "Enum member `GREEN` has type `str`, must match the `_value_` attribute annotation of `int`",
-      "description": "Enum member `GREEN` has type `str`, must match the `_value_` attribute annotation of `int`",
+      "concise_description": "Enum member `GREEN` has type `Literal['green']`, must match the `_value_` attribute annotation of `int`",
+      "description": "Enum member `GREEN` has type `Literal['green']`, must match the `_value_` attribute annotation of `int`",
       "line": 78,
       "name": "bad-assignment",
       "severity": "error",

crates/pyrefly_types/src/literal.rs

@@ -13,6 +13,7 @@ use pyrefly_derive::TypeEq;
 use pyrefly_derive::Visit;
 use pyrefly_derive::VisitMut;
 use pyrefly_util::assert_words;
+use pyrefly_util::visit::VisitMut;
 use ruff_python_ast::ExprBooleanLiteral;
 use ruff_python_ast::ExprBytesLiteral;
 use ruff_python_ast::ExprFString;
@@ -57,15 +58,27 @@ pub enum Lit {
 }
 
 #[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
-#[derive(Visit, VisitMut, TypeEq)]
+#[derive(Visit, TypeEq)]
 pub struct LitEnum {
     pub class: ClassType,
     pub member: Name,
     /// Raw type assigned to name in class def.
     /// We store the raw type so we can return it when the value or _value_ attribute is accessed.
+    /// NOTE: Intentionally excluded from VisitMut so that type transformations like
+    /// `promote_implicit_literals` don't mutate this metadata field, which must remain
+    /// stable for `.value` resolution.
     pub ty: Type,
 }
 
+/// Manual VisitMut that skips the `ty` field. The `ty` is semantic metadata for `.value`
+/// resolution and must not be mutated by recursive type transformations (e.g. literal promotion).
+/// We still recurse into `class` so that type arguments on generic enums are visited.
+impl VisitMut<Type> for LitEnum {
+    fn recurse_mut(&mut self, f: &mut dyn FnMut(&mut Type)) {
+        self.class.visit_mut(f);
+    }
+}
+
 impl Display for Lit {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         match self {

pyrefly/lib/alt/class/class_field.rs

@@ -1762,25 +1762,27 @@ impl<'a, Ans: LookupAnswer> AnswersSolver<'a, Ans> {
         // Determine the final type, promoting literals when appropriate.
         // Skip literal promotion for NNModule types: their fields are captured
         // constructor args that must preserve literal types for shape inference.
-        let ty = if matches!(value_ty, Type::NNModule(_)) {
-            value_ty
+        let (ty, unpromoted_ty) = if matches!(value_ty, Type::NNModule(_)) {
+            (value_ty, None)
         } else {
             let mut has_implicit_literal = value_ty.is_implicit_literal();
             if !has_implicit_literal && matches!(initialization, ClassFieldInitialization::Method) {
                 value_ty.universe(&mut |current_type_node| {
                     has_implicit_literal |= current_type_node.is_implicit_literal();
                 });
             }
+            // Save any unpromoted literal types, we need them for enums
             if annotation
                 .as_ref()
                 .and_then(|ann| ann.ty.as_ref())
                 .is_none()
                 && matches!(read_only_reason, None | Some(ReadOnlyReason::NamedTuple))
                 && has_implicit_literal
             {
-                value_ty.promote_implicit_literals(self.stdlib)
+                let pre = value_ty.clone();
+                (value_ty.promote_implicit_literals(self.stdlib), Some(pre))
             } else {
-                value_ty
+                (value_ty, None)
             }
         };
 
@@ -1864,6 +1866,7 @@ impl<'a, Ans: LookupAnswer> AnswersSolver<'a, Ans> {
             name,
             direct_annotation.as_ref(),
             &ty,
+            unpromoted_ty.as_ref(),
             field_definition,
             descriptor.is_some(),
             range,
@@ -2105,6 +2108,7 @@ impl<'a, Ans: LookupAnswer> AnswersSolver<'a, Ans> {
         name: &Name,
         direct_annotation: Option<&Annotation>,
         ty: &Type,
+        unpromoted_ty: Option<&Type>,
         field_definition: &ClassFieldDefinition,
         is_descriptor: bool,
         range: TextRange,
@@ -2114,7 +2118,7 @@ impl<'a, Ans: LookupAnswer> AnswersSolver<'a, Ans> {
             class,
             name,
             direct_annotation,
-            ty,
+            unpromoted_ty.unwrap_or(ty),
             field_definition,
             is_descriptor,
             range,
@@ -3993,11 +3997,21 @@ impl<'a, Ans: LookupAnswer> AnswersSolver<'a, Ans> {
         field: &Name,
         ancestor: (&str, &str),
     ) -> bool {
-        let member = self.get_class_member_with_defining_class(cls, field);
-        match member {
-            Some(member) => member.is_defined_on(ancestor.0, ancestor.1),
-            None => false,
-        }
+        self.field_defining_class_matches(cls, field, |c| {
+            c.has_toplevel_qname(ancestor.0, ancestor.1)
+        })
+    }
+
+    /// Check whether the defining class of `field` on `cls` satisfies `predicate`.
+    /// Returns false if the field does not exist.
+    pub fn field_defining_class_matches(
+        &self,
+        cls: &Class,
+        field: &Name,
+        predicate: impl FnOnce(&Class) -> bool,
+    ) -> bool {
+        self.get_class_member_with_defining_class(cls, field)
+            .is_some_and(|member| predicate(&member.defining_class))
     }
 
     /// Get the class's `__new__` method.