From b69c358aebc81ebff0459e8113b35c49c18d5f24 Mon Sep 17 00:00:00 2001 From: Justin Chapman Date: Tue, 23 Sep 2025 19:55:32 -0400 Subject: [PATCH 1/3] [ty] handle more enum.auto() cases --- .../resources/mdtest/enums.md | 40 +++++++++++++++++++ crates/ty_python_semantic/src/types.rs | 10 +++++ crates/ty_python_semantic/src/types/class.rs | 17 +++++++- crates/ty_python_semantic/src/types/enums.rs | 33 ++++++++++++--- 4 files changed, 93 insertions(+), 7 deletions(-) diff --git a/crates/ty_python_semantic/resources/mdtest/enums.md b/crates/ty_python_semantic/resources/mdtest/enums.md index c526e111243a5..9d76020b24159 100644 --- a/crates/ty_python_semantic/resources/mdtest/enums.md +++ b/crates/ty_python_semantic/resources/mdtest/enums.md @@ -320,6 +320,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: @@ -348,6 +353,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: @@ -363,6 +373,36 @@ 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: Any + +class B(bytes, Enum): + X = auto() + Y = auto() + +reveal_type(B.X.value) # revealed: Any + +class C(tuple, Enum): + X = auto() + Y = auto() + +reveal_type(C.X.value) # revealed: Any + +class D(float, Enum): + X = auto() + Y = auto() + +reveal_type(D.X.value) # revealed: Any +``` + Combining aliases with `auto()`: ```py diff --git a/crates/ty_python_semantic/src/types.rs b/crates/ty_python_semantic/src/types.rs index e3b8b8e89e99c..63211d524903f 100644 --- a/crates/ty_python_semantic/src/types.rs +++ b/crates/ty_python_semantic/src/types.rs @@ -4365,6 +4365,16 @@ impl<'db> Type<'db> { Place::bound(todo_type!("ParamSpecArgs / ParamSpecKwargs")).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::Undefined, Place::bound) + .into() + } + Type::NominalInstance(..) | Type::ProtocolInstance(..) | Type::BooleanLiteral(..) diff --git a/crates/ty_python_semantic/src/types/class.rs b/crates/ty_python_semantic/src/types/class.rs index 862ed4b974c8a..16f58acb741f9 100644 --- a/crates/ty_python_semantic/src/types/class.rs +++ b/crates/ty_python_semantic/src/types/class.rs @@ -3778,6 +3778,7 @@ pub enum KnownClass { Member, Nonmember, StrEnum, + IntEnum, // abc ABCMeta, // Types @@ -3925,6 +3926,7 @@ impl KnownClass { | Self::Member | Self::Nonmember | Self::StrEnum + | Self::IntEnum | Self::ABCMeta | Self::Iterable | Self::Iterator @@ -3986,6 +3988,7 @@ impl KnownClass { | KnownClass::Member | KnownClass::Nonmember | KnownClass::StrEnum + | KnownClass::IntEnum | KnownClass::ABCMeta | KnownClass::GenericAlias | KnownClass::ModuleType @@ -4069,6 +4072,7 @@ impl KnownClass { | KnownClass::Member | KnownClass::Nonmember | KnownClass::StrEnum + | KnownClass::IntEnum | KnownClass::ABCMeta | KnownClass::GenericAlias | KnownClass::ModuleType @@ -4152,6 +4156,7 @@ impl KnownClass { | KnownClass::Member | KnownClass::Nonmember | KnownClass::StrEnum + | KnownClass::IntEnum | KnownClass::ABCMeta | KnownClass::GenericAlias | KnownClass::ModuleType @@ -4274,6 +4279,7 @@ impl KnownClass { | Self::Member | Self::Nonmember | Self::StrEnum + | Self::IntEnum | Self::ABCMeta | Self::Super | Self::StdlibAlias @@ -4330,6 +4336,7 @@ impl KnownClass { | KnownClass::Member | KnownClass::Nonmember | KnownClass::StrEnum + | KnownClass::IntEnum | KnownClass::ABCMeta | KnownClass::GenericAlias | KnownClass::ModuleType @@ -4447,6 +4454,7 @@ impl KnownClass { Self::Member => "member", Self::Nonmember => "nonmember", Self::StrEnum => "StrEnum", + Self::IntEnum => "IntEnum", Self::ABCMeta => "ABCMeta", Self::Super => "super", Self::Iterable => "Iterable", @@ -4719,7 +4727,8 @@ impl KnownClass { | Self::Auto | Self::Member | Self::Nonmember - | Self::StrEnum => KnownModule::Enum, + | Self::StrEnum + | Self::IntEnum => KnownModule::Enum, Self::GenericAlias | Self::ModuleType | Self::FunctionType @@ -4850,6 +4859,7 @@ impl KnownClass { | Self::Member | Self::Nonmember | Self::StrEnum + | Self::IntEnum | Self::ABCMeta | Self::Super | Self::NewType @@ -4937,6 +4947,7 @@ impl KnownClass { | Self::Member | Self::Nonmember | Self::StrEnum + | Self::IntEnum | Self::ABCMeta | Self::Super | Self::UnionType @@ -5028,6 +5039,9 @@ 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], @@ -5106,6 +5120,7 @@ impl KnownClass { | Self::Member | Self::Nonmember | Self::StrEnum + | Self::IntEnum | Self::ABCMeta | Self::Super | Self::NotImplementedType diff --git a/crates/ty_python_semantic/src/types/enums.rs b/crates/ty_python_semantic/src/types/enums.rs index 671b919929ab2..3e72d06dc76c0 100644 --- a/crates/ty_python_semantic/src/types/enums.rs +++ b/crates/ty_python_semantic/src/types/enums.rs @@ -68,9 +68,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); @@ -141,14 +138,38 @@ 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 { + } 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)) + }) + }); + if has_custom_mixin { + Type::any() + } else { + Type::IntLiteral(auto_counter) + } + }; + Some(auto_value_ty) } _ => None, From 05ad42adae3f043784473a6617ab21a482bf9780 Mon Sep 17 00:00:00 2001 From: Alex Waygood Date: Sun, 9 Nov 2025 23:52:59 +0000 Subject: [PATCH 2/3] Generalize special case for enums that have `int` mixins --- .../resources/mdtest/enums.md | 13 +++++ crates/ty_python_semantic/src/types/class.rs | 17 +------ crates/ty_python_semantic/src/types/enums.rs | 50 +++++++++++-------- 3 files changed, 44 insertions(+), 36 deletions(-) diff --git a/crates/ty_python_semantic/resources/mdtest/enums.md b/crates/ty_python_semantic/resources/mdtest/enums.md index 9d76020b24159..c766a1327b1bf 100644 --- a/crates/ty_python_semantic/resources/mdtest/enums.md +++ b/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 diff --git a/crates/ty_python_semantic/src/types/class.rs b/crates/ty_python_semantic/src/types/class.rs index 16f58acb741f9..862ed4b974c8a 100644 --- a/crates/ty_python_semantic/src/types/class.rs +++ b/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 diff --git a/crates/ty_python_semantic/src/types/enums.rs b/crates/ty_python_semantic/src/types/enums.rs index 3e72d06dc76c0..dbde33922123d 100644 --- a/crates/ty_python_semantic/src/types/enums.rs +++ b/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,6 +138,8 @@ 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)) { @@ -145,28 +147,36 @@ pub(crate) fn enum_metadata<'db>( 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; 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) From f74e0b3ea2e38a4eb89d15ede4479339e4dfcbd3 Mon Sep 17 00:00:00 2001 From: Alex Waygood Date: Mon, 10 Nov 2025 00:00:26 +0000 Subject: [PATCH 3/3] tweak mdtest prose --- crates/ty_python_semantic/resources/mdtest/enums.md | 5 ++++- 1 file changed, 4 insertions(+), 1 deletion(-) diff --git a/crates/ty_python_semantic/resources/mdtest/enums.md b/crates/ty_python_semantic/resources/mdtest/enums.md index c766a1327b1bf..bdd2a929954e7 100644 --- a/crates/ty_python_semantic/resources/mdtest/enums.md +++ b/crates/ty_python_semantic/resources/mdtest/enums.md @@ -386,7 +386,10 @@ reveal_type(Answer.YES.value) # revealed: Literal[1] reveal_type(Answer.NO.value) # revealed: Literal[2] ``` -Using `auto()` with non-integer mixins: +It's [hard to predict](https://github.com/astral-sh/ruff/pull/20541#discussion_r2381878613) what the +effect of using `auto()` will be for an arbitrary non-integer mixin, so for anything that isn't a +`StrEnum` and has a non-`int` mixin, we simply fallback to typeshed's annotation of `Any` for the +`value` property: ```python from enum import Enum, auto