Generalize special case for enums that have int mixins

Author: AlexWaygood

crates/ty_python_semantic/resources/mdtest/enums.md

@@ -373,6 +373,19 @@ reveal_type(Answer.YES.value)  # revealed: Literal[1]
 reveal_type(Answer.NO.value)  # revealed: Literal[2]
 ```
 
+As does using `auto()` for other enums that use `int` as a mixin:
+
+```py
+from enum import Enum, auto
+
+class Answer(int, Enum):
+    YES = auto()
+    NO = auto()
+
+reveal_type(Answer.YES.value)  # revealed: Literal[1]
+reveal_type(Answer.NO.value)  # revealed: Literal[2]
+```
+
 Using `auto()` with non-integer mixins:
 
 ```python

crates/ty_python_semantic/src/types/class.rs

@@ -3778,7 +3778,6 @@ pub enum KnownClass {
     Member,
     Nonmember,
     StrEnum,
-    IntEnum,
     // abc
     ABCMeta,
     // Types
@@ -3926,7 +3925,6 @@ impl KnownClass {
             | Self::Member
             | Self::Nonmember
             | Self::StrEnum
-            | Self::IntEnum
             | Self::ABCMeta
             | Self::Iterable
             | Self::Iterator
@@ -3988,7 +3986,6 @@ impl KnownClass {
             | KnownClass::Member
             | KnownClass::Nonmember
             | KnownClass::StrEnum
-            | KnownClass::IntEnum
             | KnownClass::ABCMeta
             | KnownClass::GenericAlias
             | KnownClass::ModuleType
@@ -4072,7 +4069,6 @@ impl KnownClass {
             | KnownClass::Member
             | KnownClass::Nonmember
             | KnownClass::StrEnum
-            | KnownClass::IntEnum
             | KnownClass::ABCMeta
             | KnownClass::GenericAlias
             | KnownClass::ModuleType
@@ -4156,7 +4152,6 @@ impl KnownClass {
             | KnownClass::Member
             | KnownClass::Nonmember
             | KnownClass::StrEnum
-            | KnownClass::IntEnum
             | KnownClass::ABCMeta
             | KnownClass::GenericAlias
             | KnownClass::ModuleType
@@ -4279,7 +4274,6 @@ impl KnownClass {
             | Self::Member
             | Self::Nonmember
             | Self::StrEnum
-            | Self::IntEnum
             | Self::ABCMeta
             | Self::Super
             | Self::StdlibAlias
@@ -4336,7 +4330,6 @@ impl KnownClass {
             | KnownClass::Member
             | KnownClass::Nonmember
             | KnownClass::StrEnum
-            | KnownClass::IntEnum
             | KnownClass::ABCMeta
             | KnownClass::GenericAlias
             | KnownClass::ModuleType
@@ -4454,7 +4447,6 @@ impl KnownClass {
             Self::Member => "member",
             Self::Nonmember => "nonmember",
             Self::StrEnum => "StrEnum",
-            Self::IntEnum => "IntEnum",
             Self::ABCMeta => "ABCMeta",
             Self::Super => "super",
             Self::Iterable => "Iterable",
@@ -4727,8 +4719,7 @@ impl KnownClass {
             | Self::Auto
             | Self::Member
             | Self::Nonmember
-            | Self::StrEnum
-            | Self::IntEnum => KnownModule::Enum,
+            | Self::StrEnum => KnownModule::Enum,
             Self::GenericAlias
             | Self::ModuleType
             | Self::FunctionType
@@ -4859,7 +4850,6 @@ impl KnownClass {
             | Self::Member
             | Self::Nonmember
             | Self::StrEnum
-            | Self::IntEnum
             | Self::ABCMeta
             | Self::Super
             | Self::NewType
@@ -4947,7 +4937,6 @@ impl KnownClass {
             | Self::Member
             | Self::Nonmember
             | Self::StrEnum
-            | Self::IntEnum
             | Self::ABCMeta
             | Self::Super
             | Self::UnionType
@@ -5039,9 +5028,6 @@ impl KnownClass {
             "StrEnum" if Program::get(db).python_version(db) >= PythonVersion::PY311 => {
                 &[Self::StrEnum]
             }
-            "IntEnum" if Program::get(db).python_version(db) >= PythonVersion::PY311 => {
-                &[Self::IntEnum]
-            }
             "auto" => &[Self::Auto],
             "member" => &[Self::Member],
             "nonmember" => &[Self::Nonmember],
@@ -5120,7 +5106,6 @@ impl KnownClass {
             | Self::Member
             | Self::Nonmember
             | Self::StrEnum
-            | Self::IntEnum
             | Self::ABCMeta
             | Self::Super
             | Self::NotImplementedType

crates/ty_python_semantic/src/types/enums.rs

@@ -6,7 +6,7 @@ use crate::{
     place::{Place, PlaceAndQualifiers, place_from_bindings, place_from_declarations},
     semantic_index::{place_table, use_def_map},
     types::{
-        ClassLiteral, DynamicType, EnumLiteralType, KnownClass, MemberLookupPolicy,
+        ClassBase, ClassLiteral, DynamicType, EnumLiteralType, KnownClass, MemberLookupPolicy,
         StringLiteralType, Type, TypeQualifiers,
     },
 };
@@ -138,35 +138,45 @@ pub(crate) fn enum_metadata<'db>(
                             // enum.auto
                             Some(KnownClass::Auto) => {
                                 auto_counter += 1;
+
+                                // `StrEnum`s have different `auto()` behaviour to enums inheriting from `(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::IntEnum.to_subclass_of(db))
-                                {
-                                    Type::IntLiteral(auto_counter)
                                 } else {
-                                    let has_custom_mixin =
-                                        class.iter_mro(db, None).skip(1).any(|base| {
-                                            base.into_class().is_some_and(|class| {
-                                                !(class.is_object(db)
-                                                    || KnownClass::Enum
-                                                        .to_subclass_of(db)
-                                                        .to_class_type(db)
-                                                        .is_some_and(|enum_class| {
-                                                            class.is_subclass_of(db, enum_class)
-                                                        })
-                                                    || class.is_known(db, KnownClass::Enum))
+                                    let custom_mixins: smallvec::SmallVec<[Option<KnownClass>; 1]> =
+                                        class
+                                            .iter_mro(db, None)
+                                            .skip(1)
+                                            .filter_map(ClassBase::into_class)
+                                            .filter(|class| {
+                                                !Type::from(*class).is_subtype_of(
+                                                    db,
+                                                    KnownClass::Enum.to_subclass_of(db),
+                                                )
                                             })
-                                        });
-                                    if has_custom_mixin {
-                                        Type::any()
-                                    } else {
+                                            .map(|class| class.known(db))
+                                            .filter(|class| {
+                                                !matches!(class, Some(KnownClass::Object))
+                                            })
+                                            .collect();
+
+                                    // `IntEnum`s have the same `auto()` behaviour to enums inheriting from `(int, Enum)`,
+                                    // and `IntEnum`s also have `int` in their MROs, so both cases are handled here.
+                                    //
+                                    // In general, the `auto()` behaviour for enums with non-`int` mixins is hard to predict,
+                                    // so we fall back to `Any` in those cases.
+                                    if matches!(
+                                        custom_mixins.as_slice(),
+                                        [] | [Some(KnownClass::Int)]
+                                    ) {
                                         Type::IntLiteral(auto_counter)
+                                    } else {
+                                        Type::any()
                                     }
                                 };
                                 Some(auto_value_ty)