[ty] static/functional parity

Author: thejchap

crates/ty_python_semantic/resources/mdtest/enums.md

@@ -641,6 +641,30 @@ reveal_type(ManyAliases.alias3.value)  # revealed: Literal["real_member"]
 reveal_type(ManyAliases.alias3.name)  # revealed: Literal["real_member"]
 ```
 
+Functional enums also detect duplicate-value aliases in both dict and list-of-tuples forms:
+
+```py
+from enum import Enum
+from ty_extensions import enum_members
+
+DictAlias = Enum("DictAlias", {"A": 1, "B": 1})
+
+# revealed: tuple[Literal["A"]]
+reveal_type(enum_members(DictAlias))
+
+# single-member enum is a singleton, so member access resolves to the instance type
+reveal_type(DictAlias.A)  # revealed: DictAlias
+reveal_type(DictAlias.B)  # revealed: DictAlias
+
+PairsAlias = Enum("PairsAlias", [("A", 1), ("B", 1)])
+
+# revealed: tuple[Literal["A"]]
+reveal_type(enum_members(PairsAlias))
+
+reveal_type(PairsAlias.A)  # revealed: PairsAlias
+reveal_type(PairsAlias.B)  # revealed: PairsAlias
+```
+
 ### Using `auto()`
 
 ```toml
@@ -683,6 +707,24 @@ reveal_type(Mixed.MANUAL_2.value)  # revealed: Literal[-2]
 reveal_type(Mixed.AUTO_2.value)  # revealed: Literal[2]
 ```
 
+If `auto()` follows a non-literal value, the generated value widens to `int` since the previous
+value isn't known at type-check time:
+
+```py
+def f(n: int):
+    class StaticDynamic(Enum):
+        A = n
+        B = auto()
+
+    reveal_type(StaticDynamic.A.value)  # revealed: int
+    reveal_type(StaticDynamic.B.value)  # revealed: int
+
+    Dynamic = Enum("Dynamic", {"A": n, "B": auto()})
+
+    reveal_type(Dynamic.A.value)  # revealed: int
+    reveal_type(Dynamic.B.value)  # revealed: int
+```
+
 When using `auto()` with `StrEnum`, the value is the lowercase name of the member:
 
 ```py
@@ -1410,6 +1452,24 @@ reveal_type(Mixed.B.value)  # revealed: Literal[11]
 reveal_type(Mixed.C.value)  # revealed: Literal[12]
 ```
 
+### `auto()` in tuple/list entries
+
+`auto()` should also expand in tuple/list entry forms of the functional syntax:
+
+```py
+from enum import Enum, Flag, auto
+
+Color = Enum("Color", [("RED", auto()), ("GREEN", auto())])
+
+reveal_type(Color.RED.value)  # revealed: Literal[1]
+reveal_type(Color.GREEN.value)  # revealed: Literal[2]
+
+Perm = Flag("Perm", (("READ", auto()), ("WRITE", auto())))
+
+reveal_type(Perm.READ.value)  # revealed: Literal[1]
+reveal_type(Perm.WRITE.value)  # revealed: Literal[2]
+```
+
 ### Duplicate member names
 
 Duplicate member names raise `TypeError` at runtime. We degrade to unknown members rather than
@@ -1503,6 +1563,19 @@ from enum import Enum
 Color = Enum("Color", "RED GREEN BLUE", bad_kwarg=True)
 ```
 
+### Keyword argument type validation
+
+Functional enum construction should still preserve overload-based argument validation:
+
+```py
+from enum import Enum
+
+# error: [invalid-argument-type]
+Color = Enum("Color", "RED", start="0")
+
+reveal_type(Color.RED.value)  # revealed: Literal[1]
+```
+
 ### `boundary` keyword (Python 3.11+)
 
 #### Available on 3.11+
@@ -1576,6 +1649,43 @@ reveal_type(Http.OK.value)  # revealed: Literal[1]
 reveal_type(Http.NOT_FOUND.value)  # revealed: Literal[2]
 ```
 
+Functional enums should still validate `type=` arguments eagerly, both for obvious non-types and for
+bases that are structurally invalid to combine with `Enum`:
+
+```py
+from enum import Enum
+from typing import TypedDict
+
+# error: [invalid-argument-type]
+BadType = Enum("BadType", "RED", type=1)
+
+# error: [invalid-argument-type]
+BadStringType = Enum("BadStringType", "RED", type="Mixin")
+
+TD = TypedDict("TD", {"x": int})
+
+# error: [invalid-base]
+BadBase = Enum("BadBase", "RED", type=TD)
+```
+
+Functional enums with a `type=` mixin should also have the same MRO as the equivalent static enum
+class:
+
+```py
+from enum import Enum
+from ty_extensions import reveal_mro
+
+Http = Enum("Http", "OK NOT_FOUND", type=int)
+
+reveal_mro(Http)  # revealed: (<class 'Http'>, <class 'int'>, <class 'Enum'>, <class 'object'>)
+
+class StaticHttp(int, Enum):
+    OK = 1
+    NOT_FOUND = 2
+
+reveal_mro(StaticHttp)  # revealed: (<class 'StaticHttp'>, <class 'int'>, <class 'Enum'>, <class 'object'>)
+```
+
 ### IntEnum function syntax
 
 ```py
@@ -1638,6 +1748,59 @@ reveal_type(BigFlag.X.value)  # revealed: Literal[4611686018427387904]
 reveal_type(BigFlag.Y.value)  # revealed: int
 ```
 
+### Accessing members from instances
+
+```py
+from enum import Enum
+
+Answer = Enum("Answer", "YES NO")
+
+reveal_type(Answer.YES.NO)  # revealed: Literal[Answer.NO]
+
+def _(answer: Answer) -> None:
+    reveal_type(answer.YES)  # revealed: Literal[Answer.YES]
+    reveal_type(answer.NO)  # revealed: Literal[Answer.NO]
+```
+
+### Accessing members from `type[…]`
+
+```py
+from enum import Enum
+
+Answer = Enum("Answer", "YES NO")
+
+def _(answer: type[Answer]) -> None:
+    reveal_type(answer.YES)  # revealed: Literal[Answer.YES]
+    reveal_type(answer.NO)  # revealed: Literal[Answer.NO]
+```
+
+### Implicitly final
+
+Functional enums with members should also be implicitly final:
+
+```py
+from enum import Enum
+
+Color = Enum("Color", "RED GREEN BLUE")
+
+# error: [subclass-of-final-class]
+class ExtendedColor(Color):
+    YELLOW = 4
+```
+
+### Meta-type
+
+```py
+from enum import Enum
+
+Answer = Enum("Answer", "YES NO")
+
+reveal_type(type(Answer.YES))  # revealed: <class 'Answer'>
+
+def _(answer: Answer):
+    reveal_type(type(answer))  # revealed: <class 'Answer'>
+```
+
 ## Exhaustiveness checking
 
 ## `if` statements
@@ -1744,6 +1907,80 @@ def singleton_check(value: Singleton) -> str:
             assert_never(value)
 ```
 
+## `if` statements (function syntax)
+
+```py
+from enum import Enum
+from typing_extensions import assert_never
+
+Color = Enum("Color", "RED GREEN BLUE")
+
+def color_name(color: Color) -> str:
+    if color is Color.RED:
+        return "Red"
+    elif color is Color.GREEN:
+        return "Green"
+    elif color is Color.BLUE:
+        return "Blue"
+    else:
+        assert_never(color)
+
+def color_name_without_assertion(color: Color) -> str:
+    if color is Color.RED:
+        return "Red"
+    elif color is Color.GREEN:
+        return "Green"
+    elif color is Color.BLUE:
+        return "Blue"
+
+def color_name_misses_one_variant(color: Color) -> str:
+    if color is Color.RED:
+        return "Red"
+    elif color is Color.GREEN:
+        return "Green"
+    else:
+        assert_never(color)  # error: [type-assertion-failure] "Type `Literal[Color.BLUE]` is not equivalent to `Never`"
+```
+
+## `match` statements (function syntax)
+
+TODO: `match` exhaustiveness does not yet work for functional enums. The pattern matching narrowing
+path does not resolve functional enum members the same way `is` comparisons do.
+
+```toml
+[environment]
+python-version = "3.10"
+```
+
+```py
+from enum import Enum
+from typing_extensions import assert_never
+
+Color = Enum("Color", "RED GREEN BLUE")
+
+# TODO: `assert_never` should not fire here (exhaustive match).
+def color_name(color: Color) -> str:
+    match color:
+        case Color.RED:
+            return "Red"
+        case Color.GREEN:
+            return "Green"
+        case Color.BLUE:
+            return "Blue"
+        case _:
+            assert_never(color)  # error: [type-assertion-failure]
+
+# TODO: This should ideally emit `Literal[Color.BLUE]` in the assertion, not `Color`.
+def color_name_misses_one_variant(color: Color) -> str:
+    match color:
+        case Color.RED:
+            return "Red"
+        case Color.GREEN:
+            return "Green"
+        case _:
+            assert_never(color)  # error: [type-assertion-failure] "Type `Color` is not equivalent to `Never`"
+```
+
 ## `__eq__` and `__ne__`
 
 ### No `__eq__` or `__ne__` overrides

crates/ty_python_semantic/src/types/class.rs

@@ -547,12 +547,12 @@ impl<'db> ClassLiteral<'db> {
     pub(crate) fn is_final(self, db: &'db dyn Db) -> bool {
         match self {
             Self::Static(class) => class.is_final(db),
+            Self::DynamicEnum(enum_lit) => {
+                crate::types::enums::enum_metadata(db, Self::DynamicEnum(enum_lit)).is_some()
+            }
             // Dynamic classes created via `type()`, `collections.namedtuple()`, etc. cannot be
             // marked as final.
-            Self::Dynamic(_)
-            | Self::DynamicNamedTuple(_)
-            | Self::DynamicTypedDict(_)
-            | Self::DynamicEnum(_) => false,
+            Self::Dynamic(_) | Self::DynamicNamedTuple(_) | Self::DynamicTypedDict(_) => false,
         }
     }