[ty] handle more enum.auto() cases

Author: thejchap

crates/ty_python_semantic/resources/mdtest/enums.md

@@ -285,6 +285,11 @@ reveal_type(enum_members(Answer))
 
 reveal_type(Answer.YES.value)  # revealed: Literal[1]
 reveal_type(Answer.NO.value)  # revealed: Literal[2]
+
+class SingleMember(Enum):
+    SINGLE = auto()
+
+reveal_type(SingleMember.SINGLE.value)  # revealed: Literal[1]
 ```
 
 Usages of `auto()` can be combined with manual value assignments:
@@ -313,6 +318,11 @@ class Answer(StrEnum):
 
 reveal_type(Answer.YES.value)  # revealed: Literal["yes"]
 reveal_type(Answer.NO.value)  # revealed: Literal["no"]
+
+class SingleMember(StrEnum):
+    SINGLE = auto()
+
+reveal_type(SingleMember.SINGLE.value)  # revealed: Literal["single"]
 ```
 
 Using `auto()` with `IntEnum` also works as expected:
@@ -328,6 +338,24 @@ reveal_type(Answer.YES.value)  # revealed: Literal[1]
 reveal_type(Answer.NO.value)  # revealed: Literal[2]
 ```
 
+Using `auto()` with non-integer mixins:
+
+```python
+from enum import Enum, auto
+
+class A(str, Enum):
+    X = auto()
+    Y = auto()
+
+reveal_type(A.X.value)  # revealed: str
+
+class B(bytes, Enum):
+    X = auto()
+    Y = auto()
+
+reveal_type(B.X.value)  # revealed: bytes
+```
+
 Combining aliases with `auto()`:
 
 ```py

crates/ty_python_semantic/src/types.rs

@@ -3592,6 +3592,16 @@ impl<'db> Type<'db> {
                     .into()
             }
 
+            Type::NominalInstance(instance)
+                if matches!(name_str, "value" | "_value_")
+                    && is_single_member_enum(db, instance.class(db).class_literal(db).0) =>
+            {
+                enum_metadata(db, instance.class(db).class_literal(db).0)
+                    .and_then(|metadata| metadata.members.get_index(0).map(|(_, v)| *v))
+                    .map_or(Place::Unbound, Place::bound)
+                    .into()
+            }
+
             Type::NominalInstance(..)
             | Type::ProtocolInstance(..)
             | Type::BooleanLiteral(..)

crates/ty_python_semantic/src/types/enums.rs

@@ -77,9 +77,6 @@ pub(crate) fn enum_metadata<'db>(
         return None;
     }
 
-    let is_str_enum =
-        Type::ClassLiteral(class).is_subtype_of(db, KnownClass::StrEnum.to_subclass_of(db));
-
     let scope_id = class.body_scope(db);
     let use_def_map = use_def_map(db, scope_id);
     let table = place_table(db, scope_id);
@@ -150,14 +147,25 @@ pub(crate) fn enum_metadata<'db>(
                             // enum.auto
                             Some(KnownClass::Auto) => {
                                 auto_counter += 1;
-                                Some(if is_str_enum {
+                                let auto_value_ty = if (Type::ClassLiteral(class)
+                                    .is_subtype_of(db, KnownClass::StrEnum.to_subclass_of(db)))
+                                {
                                     Type::StringLiteral(StringLiteralType::new(
                                         db,
                                         name.to_lowercase().as_str(),
                                     ))
+                                } else if (Type::ClassLiteral(class)
+                                    .is_subtype_of(db, KnownClass::Str.to_subclass_of(db)))
+                                {
+                                    KnownClass::Str.to_instance(db)
+                                } else if (Type::ClassLiteral(class)
+                                    .is_subtype_of(db, KnownClass::Bytes.to_subclass_of(db)))
+                                {
+                                    KnownClass::Bytes.to_instance(db)
                                 } else {
                                     Type::IntLiteral(auto_counter)
-                                })
+                                };
+                                Some(auto_value_ty)
                             }
 
                             _ => None,