`Enum.value` typed as `Any` when using `functools.cache`

[kmurphy4]

Bug Report

If I define a method with @functools.cache on an Enum, then the type of that Enum's value attr becomes Any. Without the @functools.cache annotation, it gets typed correctly.

Also, this behavior does not occur if you use enum literals - i.e., Foo.BAR.value is typed correctly, but foo.value (for a foo: Foo) is wrong.

To Reproduce

https://mypy-play.net/?mypy=latest&python=3.12&gist=b2a218b8db8367b2ac62dcf583a8c4f7

Expected Behavior

The type assertion in frobnicate() should succeed.

Actual Behavior

The type assertion in frobnicate() fails 😿.

[sterliakov]

This is a deficiency in enum plugin. As a workaround you can be slightly more explicit and help mypy by marking that method as @nonmember (3.11+):

import enum
import functools
import typing as t


class Color(enum.Enum):
    RED = enum.auto()
    
    @enum.nonmember
    @functools.cache
    def lowercase_name(self) -> str:
        return self.name.lower()


t.assert_type(Color.RED.value, int)  # works


def frobnicate(color: Color) -> None:
    t.assert_type(color.value, int)

https://mypy-play.net/?mypy=latest&python=3.12&gist=eaf416f505bfebbba0c2f9c5c85fa93a

mypy/mypy/plugins/enums.py

Lines 186 to 202 in 7982761

	stnodes = (info.get(name) for name in info.names)
	# Enums _can_ have methods, instance attributes, and `nonmember`s.
	# Omit methods and attributes created by assigning to self.*
	# for our value inference.
	node_types = (
	get_proper_type(n.type) if n else None
	for n in stnodes
	if n is None or not n.implicit
	)
	proper_types = [
	_infer_value_type_with_auto_fallback(ctx, t)
	for t in node_types
	if t is None
	or (not isinstance(t, CallableType) and not is_named_instance(t, "enum.nonmember"))
	]

[kmurphy4]

Oh bummer.. do you know why the isinstance(t, CallableType) guard doesn't apply?

Further, do you have suggestions for preventing users from introducing this behavior? I'd like to avoid silently erasing .value types..

I don't think it's possible to check this at runtime (e.g., by hijacking Enum.__init__) because the enum.nonmember annotation doesn't live long enough https://github.com/python/cpython/blob/033aa5cfd856e52d5b10fc765631c16b308ee4f1/Lib/enum.py#L446-L448

I suppose it would be possible to write a flake8 plugin or similar..

[sterliakov]

isinstance(t, CallableType) guard doesn't apply

...because it isn't a CallableType due to decorator, that's just how types are represented in mypy.

suggestions for preventing users from introducing this behavior

Yeah, fix this bug! I don't think this needs a flake8 plugin or something, we can fix this issue in mypy, it just hasn't happened yet.

If I'm not mistaken, it might be as simple as

diff --git a/mypy/plugins/enums.py b/mypy/plugins/enums.py
index 8b7c5df6f..1e2d5cf39 100644
--- a/mypy/plugins/enums.py
+++ b/mypy/plugins/enums.py
@@ -184,7 +184,7 @@ def enum_value_callback(ctx: mypy.plugin.AttributeContext) -> Type:
             if _implements_new(info):
                 return ctx.default_attr_type
 
-            stnodes = (info.get(name) for name in info.names)
+            stnodes = (info.get(name) for name in info.enum_members)
 
             # Enums _can_ have methods, instance attributes, and `nonmember`s.
             # Omit methods and attributes created by assigning to self.*
@@ -197,8 +197,6 @@ def enum_value_callback(ctx: mypy.plugin.AttributeContext) -> Type:
             proper_types = [
                 _infer_value_type_with_auto_fallback(ctx, t)
                 for t in node_types
-                if t is None
-                or (not isinstance(t, CallableType) and not is_named_instance(t, "enum.nonmember"))
             ]
             underlying_type = _first(proper_types)
             if underlying_type is None:
diff --git a/test-data/unit/check-enum.test b/test-data/unit/check-enum.test
index 1ab8109ed..08d260fad 100644
--- a/test-data/unit/check-enum.test
+++ b/test-data/unit/check-enum.test
@@ -2539,3 +2539,28 @@ def check(thing: Things) -> None:
         return None
     return None  # E: Statement is unreachable
 [builtins fixtures/enum.pyi]
+
+[case testValueFallbackWithCachedMethod]
+from enum import Enum, auto
+from collections.abc import Hashable
+from typing import Callable, Generic, TypeVar
+
+_T = TypeVar("_T")
+
+class _lru_cache_wrapper(Generic[_T]):
+    def __call__(self, *args: Hashable, **kwargs: Hashable) -> _T: ...
+
+def cache(user_function: Callable[..., _T], /) -> _lru_cache_wrapper[_T]: ...
+
+class Color(Enum):
+    RED = auto()
+
+    @cache
+    def lowercase_name(self) -> str:
+        return self.name
+
+reveal_type(Color.RED.value)  # N: Revealed type is "builtins.int"
+
+def frobnicate(color: Color) -> None:
+    reveal_type(color.value)  # N: Revealed type is "builtins.int"
+[builtins fixtures/primitives.pyi]

but I really don't have enough energy right now to open a PR fixing that.

[kmurphy4]

Ahh amazing, thank you. I thought you were saying it was a fundamental issue with the implementation of the plugin :)

I went ahead and opened as #19374 if you want to take a look!