-- This test file checks Enum

[case testEnumBasics]

from enum import Enum

class Medal(Enum):

gold = 1

silver = 2

bronze = 3

reveal_type(Medal.bronze) # N: Revealed type is "Literal[__main__.Medal.bronze]?"

m = Medal.gold

if int():

m = 1 # E: Incompatible types in assignment (expression has type "int", variable has type "Medal")

[builtins fixtures/enum.pyi]

-- Creation from Enum call

-- -----------------------

[case testEnumCreatedFromStringLiteral]

from enum import Enum

from typing import Literal

x: Literal['ANT BEE CAT DOG'] = 'ANT BEE CAT DOG'

Animal = Enum('Animal', x)

reveal_type(Animal.ANT) # N: Revealed type is "Literal[__main__.Animal.ANT]?"

reveal_type(Animal.BEE) # N: Revealed type is "Literal[__main__.Animal.BEE]?"

reveal_type(Animal.CAT) # N: Revealed type is "Literal[__main__.Animal.CAT]?"

reveal_type(Animal.DOG) # N: Revealed type is "Literal[__main__.Animal.DOG]?"

[builtins fixtures/tuple.pyi]

[case testEnumCreatedFromFinalValue]

from enum import Enum

from typing import Final

x: Final['str'] = 'ANT BEE CAT DOG'

Animal = Enum('Animal', x)

reveal_type(Animal.ANT) # N: Revealed type is "Literal[__main__.Animal.ANT]?"

reveal_type(Animal.BEE) # N: Revealed type is "Literal[__main__.Animal.BEE]?"

reveal_type(Animal.CAT) # N: Revealed type is "Literal[__main__.Animal.CAT]?"

reveal_type(Animal.DOG) # N: Revealed type is "Literal[__main__.Animal.DOG]?"

[builtins fixtures/tuple.pyi]

-- Creation from EnumMeta

-- ----------------------

[case testEnumFromEnumMetaBasics]

from enum import EnumMeta

class Medal(metaclass=EnumMeta):

gold = 1

silver = "hello"

bronze = None

# Without __init__ the definition fails at runtime, but we want to verify that mypy

# uses `enum.EnumMeta` and not `enum.Enum` as the definition of what is enum.

def __init__(self, *args): pass

reveal_type(Medal.bronze) # N: Revealed type is "Literal[__main__.Medal.bronze]?"

m = Medal.gold

if int():

m = 1 # E: Incompatible types in assignment (expression has type "int", variable has type "Medal")

[builtins fixtures/tuple.pyi]

[case testEnumFromEnumMetaSubclass]

from enum import EnumMeta

class Achievement(metaclass=EnumMeta): pass

class Medal(Achievement):

gold = 1

silver = "hello"

bronze = None

# See comment in testEnumFromEnumMetaBasics

def __init__(self, *args): pass

reveal_type(Medal.bronze) # N: Revealed type is "Literal[__main__.Medal.bronze]?"

m = Medal.gold

if int():

m = 1 # E: Incompatible types in assignment (expression has type "int", variable has type "Medal")

[builtins fixtures/tuple.pyi]

[case testEnumFromEnumMetaGeneric]

from enum import EnumMeta

from typing import Generic, TypeVar

T = TypeVar("T")

class Medal(Generic[T], metaclass=EnumMeta): # E: Enum class cannot be generic

q = None

[builtins fixtures/enum.pyi]

[case testEnumNameAndValue]

from enum import Enum

class Truth(Enum):

true = True

false = False

x = ''

x = Truth.true.name

reveal_type(Truth.true.name) # N: Revealed type is "Literal['true']?"

reveal_type(Truth.false.value) # N: Revealed type is "Literal[False]?"

[builtins fixtures/bool.pyi]

[case testEnumValueExtended]

from enum import Enum

class Truth(Enum):

true = True

false = False

def infer_truth(truth: Truth) -> None:

reveal_type(truth.value) # N: Revealed type is "Literal[True]? | Literal[False]?"

[builtins fixtures/bool.pyi]

[case testEnumValueAllAuto]

from enum import Enum, auto

class Truth(Enum):

true = auto()

false = auto()

def infer_truth(truth: Truth) -> None:

reveal_type(truth.value) # N: Revealed type is "builtins.int"

[builtins fixtures/primitives.pyi]

[case testEnumValueSomeAuto]

from enum import Enum, auto

class Truth(Enum):

true = 8675309

false = auto()

def infer_truth(truth: Truth) -> None:

reveal_type(truth.value) # N: Revealed type is "builtins.int"

[builtins fixtures/primitives.pyi]

[case testEnumValueExtraMethods]

from enum import Enum

class Truth(Enum):

true = True

false = False

def foo(self) -> str:

return 'bar'

def infer_truth(truth: Truth) -> None:

reveal_type(truth.value) # N: Revealed type is "Literal[True]? | Literal[False]?"

[builtins fixtures/bool.pyi]

[case testEnumValueCustomAuto]

from enum import Enum, auto

class AutoName(Enum):

# In `typeshed`, this is a staticmethod and has more arguments,

# but I have lied a bit to keep the test stubs lean.

def _generate_next_value_(self) -> str:

return "name"

class Truth(AutoName):

true = auto()

false = auto()

def infer_truth(truth: Truth) -> None:

reveal_type(truth.value) # N: Revealed type is "builtins.str"

[builtins fixtures/primitives.pyi]

[case testEnumValueInhomogeneous]

from enum import Enum

class Truth(Enum):

true = 'True'

false = 0

def cannot_infer_truth(truth: Truth) -> None:

reveal_type(truth.value) # N: Revealed type is "Any"

[builtins fixtures/bool.pyi]

[case testEnumValueSameType]

from enum import Enum

def newbool() -> bool:

...

class Truth(Enum):

true = newbool()

false = newbool()

def infer_truth(truth: Truth) -> None:

reveal_type(truth.value) # N: Revealed type is "builtins.bool"

[builtins fixtures/bool.pyi]

[case testEnumTruthyness]

# mypy: warn-unreachable

import enum

from typing import Literal

class E(enum.Enum):

zero = 0

one = 1

def print(s: str) -> None: ...

if E.zero:

print("zero is true")

if not E.zero:

print("zero is false") # E: Statement is unreachable

if E.one:

print("one is true")

if not E.one:

print("one is false") # E: Statement is unreachable

def main(zero: Literal[E.zero], one: Literal[E.one]) -> None:

if zero:

print("zero is true")

if not zero:

print("zero is false") # E: Statement is unreachable

if one:

print("one is true")

if not one:

print("one is false") # E: Statement is unreachable

[builtins fixtures/tuple.pyi]

[case testEnumTruthynessCustomDunderBool]

# mypy: warn-unreachable

import enum

from typing import Literal

class E(enum.Enum):

zero = 0

one = 1

def __bool__(self) -> Literal[False]:

return False

def print(s: str) -> None: ...

if E.zero:

print("zero is true") # E: Statement is unreachable

if not E.zero:

print("zero is false")

if E.one:

print("one is true") # E: Statement is unreachable

if not E.one:

print("one is false")

def main(zero: Literal[E.zero], one: Literal[E.one]) -> None:

if zero:

print("zero is true") # E: Statement is unreachable

if not zero:

print("zero is false")

if one:

print("one is true") # E: Statement is unreachable

if not one:

print("one is false")

[builtins fixtures/enum.pyi]

[case testEnumTruthynessStrEnum]

# mypy: warn-unreachable

import enum

from typing import Literal

class E(enum.StrEnum):

empty = ""

not_empty = "asdf"

def print(s: str) -> None: ...

if E.empty:

print("empty is true")

if not E.empty:

print("empty is false")

if E.not_empty:

print("not_empty is true")

if not E.not_empty:

print("not_empty is false")

def main(empty: Literal[E.empty], not_empty: Literal[E.not_empty]) -> None:

if empty:

print("empty is true")

if not empty:

print("empty is false")

if not_empty:

print("not_empty is true")

if not not_empty:

print("not_empty is false")

[builtins fixtures/enum.pyi]

[case testEnumUnique]

import enum

@enum.unique

class E(enum.Enum):

x = 1

y = 1 # NOTE: This duplicate value is not detected by mypy at the moment

x = 1

x = E.x

[builtins fixtures/enum.pyi]

[out]

main:7: error: Incompatible types in assignment (expression has type "E", variable has type "int")

[case testIntEnum_assignToIntVariable]

from enum import IntEnum

class N(IntEnum):

x = 1

y = 1

n = 1

if int():

n = N.x # Subclass of int, so it's okay

s = ''

if int():

s = N.y # E: Incompatible types in assignment (expression has type "N", variable has type "str")

[builtins fixtures/enum.pyi]

[case testIntEnum_functionTakingIntEnum]

from enum import IntEnum

class SomeIntEnum(IntEnum):

x = 1

def takes_some_int_enum(n: SomeIntEnum):

pass

takes_some_int_enum(SomeIntEnum.x)

takes_some_int_enum(1) # Error

takes_some_int_enum(SomeIntEnum(1)) # How to deal with the above

[builtins fixtures/enum.pyi]

[out]

main:7: error: Argument 1 to "takes_some_int_enum" has incompatible type "int"; expected "SomeIntEnum"

[case testIntEnum_functionTakingInt]

from enum import IntEnum

class SomeIntEnum(IntEnum):

x = 1

def takes_int(i: int):

pass

takes_int(SomeIntEnum.x)

takes_int(2)

[builtins fixtures/enum.pyi]

[case testIntEnum_functionReturningIntEnum]

from enum import IntEnum

class SomeIntEnum(IntEnum):

x = 1

def returns_some_int_enum() -> SomeIntEnum:

return SomeIntEnum.x

an_int = 1

an_int = returns_some_int_enum()

an_enum = SomeIntEnum.x

an_enum = returns_some_int_enum()

[builtins fixtures/enum.pyi]

[out]

[case testStrEnumCreation]

# flags: --python-version 3.11

from enum import StrEnum

class MyStrEnum(StrEnum):

x = 'x'

y = 'y'

reveal_type(MyStrEnum.x) # N: Revealed type is "Literal[__main__.MyStrEnum.x]?"

reveal_type(MyStrEnum.x.value) # N: Revealed type is "Literal['x']?"

reveal_type(MyStrEnum.y) # N: Revealed type is "Literal[__main__.MyStrEnum.y]?"

reveal_type(MyStrEnum.y.value) # N: Revealed type is "Literal['y']?"

[builtins fixtures/enum.pyi]

[out]

[case testEnumMethods]

from enum import Enum

class Color(Enum):

red = 1

green = 2

def m(self, x: int): pass

@staticmethod

def m2(x: int): pass

Color.red.m('')

Color.m2('')

[builtins fixtures/staticmethod.pyi]

[out]

main:11: error: Argument 1 to "m" of "Color" has incompatible type "str"; expected "int"

main:12: error: Argument 1 to "m2" of "Color" has incompatible type "str"; expected "int"

[case testIntEnum_ExtendedIntEnum_functionTakingExtendedIntEnum]

from enum import IntEnum

class ExtendedIntEnum(IntEnum):

pass

class SomeExtIntEnum(ExtendedIntEnum):

x = 1

def takes_int(i: int):

pass

takes_int(SomeExtIntEnum.x)

def takes_some_ext_int_enum(s: SomeExtIntEnum):

pass

takes_some_ext_int_enum(SomeExtIntEnum.x)

[builtins fixtures/enum.pyi]

[case testNamedTupleEnum]

from typing import NamedTuple

from enum import Enum

N = NamedTuple('N', [('bar', int)])

class E(N, Enum):

X = N(1)

def f(x: E) -> None: pass

f(E.X)

[builtins fixtures/tuple.pyi]

[case testEnumCall]

from enum import IntEnum

class E(IntEnum):

a = 1

x: int

reveal_type(E(x))

[builtins fixtures/tuple.pyi]

[out]

main:5: note: Revealed type is "__main__.E"

[case testEnumIndex]

from enum import IntEnum

class E(IntEnum):

a = 1

s: str

reveal_type(E[s])

[builtins fixtures/enum.pyi]

[out]

main:5: note: Revealed type is "__main__.E"

[case testEnumIndexError]

from enum import IntEnum

class E(IntEnum):

a = 1

E[1] # E: Enum index should be a string (actual index type "int")

x = E[1] # E: Enum index should be a string (actual index type "int")

[builtins fixtures/enum.pyi]

[case testEnumIndexIsNotAnAlias]

from enum import Enum

class E(Enum):

a = 1

b = 2

reveal_type(E['a']) # N: Revealed type is "__main__.E"

E['a']

x = E['a']

reveal_type(x) # N: Revealed type is "__main__.E"

def get_member(name: str) -> E:

val = E[name]

return val

reveal_type(get_member('a')) # N: Revealed type is "__main__.E"

[builtins fixtures/enum.pyi]

[case testGenericEnum]

from enum import Enum

from typing import Generic, TypeVar

T = TypeVar('T')

class F(Generic[T], Enum): # E: Enum class cannot be generic

x: T

y: T

reveal_type(F[int].x) # E: Access to generic instance variables via class is ambiguous \

# N: Revealed type is "builtins.int"

[builtins fixtures/enum.pyi]

[case testEnumFlag]

from enum import Flag

class C(Flag):

a = 1

b = 2

x = C.a

if int():

x = 1 # E: Incompatible types in assignment (expression has type "int", variable has type "C")

if int():

x = x | C.b

[builtins fixtures/enum.pyi]

[case testEnumIntFlag]

from enum import IntFlag

class C(IntFlag):

a = 1

b = 2

x = C.a

if int():

x = 1 # E: Incompatible types in assignment (expression has type "int", variable has type "C")

if int():

x = x | C.b

[builtins fixtures/enum.pyi]

[case testAnonymousEnum]

from enum import Enum

class A:

def f(self) -> None:

class E(Enum):

a = 1

self.x = E.a

a = A()

reveal_type(a.x)

[builtins fixtures/enum.pyi]

[out]

main:8: note: Revealed type is "__main__.E@4"

[case testEnumInClassBody]

from enum import Enum

class A:

class E(Enum):

a = 1

class B:

class E(Enum):

a = 1

x = A.E.a

y = B.E.a

if int():

x = y # E: Incompatible types in assignment (expression has type "__main__.B.E", variable has type "__main__.A.E")

[builtins fixtures/enum.pyi]

[case testFunctionalEnumString]

from enum import Enum, IntEnum

E = Enum('E', 'foo bar')

I = IntEnum('I', ' bar, baz ')

reveal_type(E.foo)

reveal_type(E.bar.value)

reveal_type(I.bar)

reveal_type(I.baz.value)

[builtins fixtures/enum.pyi]

[out]

main:4: note: Revealed type is "Literal[__main__.E.foo]?"

main:5: note: Revealed type is "Any"

main:6: note: Revealed type is "Literal[__main__.I.bar]?"

main:7: note: Revealed type is "builtins.int"

[case testFunctionalEnumListOfStrings]

from enum import Enum, IntEnum

E = Enum('E', ('foo', 'bar'))

F = IntEnum('F', ['bar', 'baz'])

reveal_type(E.foo)

reveal_type(F.baz)

[builtins fixtures/enum.pyi]

[out]

main:4: note: Revealed type is "Literal[__main__.E.foo]?"

main:5: note: Revealed type is "Literal[__main__.F.baz]?"

[case testFunctionalEnumListOfPairs]

from enum import Enum, IntEnum

E = Enum('E', [('foo', 1), ['bar', 2]])

F = IntEnum('F', (['bar', 1], ('baz', 2)))

reveal_type(E.foo)

reveal_type(F.baz)

reveal_type(E.foo.value)

reveal_type(F.bar.name)

[builtins fixtures/enum.pyi]

[out]

main:4: note: Revealed type is "Literal[__main__.E.foo]?"

main:5: note: Revealed type is "Literal[__main__.F.baz]?"

main:6: note: Revealed type is "Literal[1]?"

main:7: note: Revealed type is "Literal['bar']?"

[case testFunctionalEnumDict]

from enum import Enum, IntEnum

E = Enum('E', {'foo': 1, 'bar': 2})

F = IntEnum('F', {'bar': 1, 'baz': 2})

reveal_type(E.foo)

reveal_type(F.baz)

reveal_type(E.foo.value)

reveal_type(F.bar.name)

[builtins fixtures/enum.pyi]

[out]

main:4: note: Revealed type is "Literal[__main__.E.foo]?"

main:5: note: Revealed type is "Literal[__main__.F.baz]?"

main:6: note: Revealed type is "Literal[1]?"

main:7: note: Revealed type is "Literal['bar']?"

[case testEnumKeywordsArgs]

from enum import Enum, IntEnum

PictureSize = Enum('PictureSize', 'P0 P1 P2 P3 P4 P5 P6 P7 P8', type=str, module=__name__)

fake_enum1 = Enum('fake_enum1', ['a', 'b'])

fake_enum2 = Enum('fake_enum2', names=['a', 'b'])

fake_enum3 = Enum(value='fake_enum3', names=['a', 'b'])

fake_enum4 = Enum(value='fake_enum4', names=['a', 'b'] , module=__name__)

[builtins fixtures/enum.pyi]

[case testFunctionalEnumErrors]

from enum import Enum, IntEnum

A = Enum('A') # E: Too few arguments for Enum()

B = Enum('B', 42) # E: Second argument of Enum() must be string, tuple, list or dict literal for mypy to determine Enum members

C = Enum('C', 'a b', 'x', 'y', 'z', 'p', 'q') # E: Too many arguments for Enum()

D = Enum('D', foo) # E: Second argument of Enum() must be string, tuple, list or dict literal for mypy to determine Enum members \

# E: Name "foo" is not defined

bar = 'x y z'

E = Enum('E', bar) # E: Second argument of Enum() must be string, tuple, list or dict literal for mypy to determine Enum members

I = IntEnum('I') # E: Too few arguments for IntEnum()

J = IntEnum('I', 42) # E: Second argument of IntEnum() must be string, tuple, list or dict literal for mypy to determine Enum members

K = IntEnum('I', 'p q', 'x', 'y', 'z', 'p', 'q') # E: Too many arguments for IntEnum()

L = Enum('L', ' ') # E: Enum() needs at least one item

M = Enum('M', ()) # E: Enum() needs at least one item

N = IntEnum('M', []) # E: IntEnum() needs at least one item

P = Enum('P', [42]) # E: Enum() with tuple or list expects strings or (name, value) pairs

Q = Enum('Q', [('a', 42, 0)]) # E: Enum() with tuple or list expects strings or (name, value) pairs

R = IntEnum('R', [[0, 42]]) # E: IntEnum() with tuple or list expects strings or (name, value) pairs

S = Enum('S', {1: 1}) # E: Enum() with dict literal requires string literals

T = Enum('T', keyword='a b') # E: Unexpected keyword argument "keyword"

U = Enum('U', *['a']) # E: Unexpected arguments to Enum()

V = Enum('U', **{'a': 1}) # E: Unexpected arguments to Enum()

W = Enum('W', 'a b')

W.c # E: "type[W]" has no attribute "c"

X = Enum('Something', 'a b') # E: String argument 1 "Something" to enum.Enum(...) does not match variable name "X"

reveal_type(X.a) # N: Revealed type is "Literal[[email protected]]?"

X.asdf # E: "type[Something@23]" has no attribute "asdf"

[builtins fixtures/tuple.pyi]

[typing fixtures/typing-medium.pyi]

[case testFunctionalEnumFlag]

from enum import Flag, IntFlag

A = Flag('A', 'x y')

B = IntFlag('B', 'a b')

reveal_type(A.x) # N: Revealed type is "Literal[__main__.A.x]?"

reveal_type(B.a) # N: Revealed type is "Literal[__main__.B.a]?"

reveal_type(A.x.name) # N: Revealed type is "Literal['x']?"

reveal_type(B.a.name) # N: Revealed type is "Literal['a']?"

reveal_type(A.x.value) # N: Revealed type is "builtins.int"

reveal_type(B.a.value) # N: Revealed type is "builtins.int"

[builtins fixtures/enum.pyi]

[case testAnonymousFunctionalEnum]

from enum import Enum

class A:

def f(self) -> None:

E = Enum('E', 'a b')

self.x = E.a

a = A()

reveal_type(a.x)

[builtins fixtures/enum.pyi]

[out]

main:7: note: Revealed type is "__main__.A.E@4"

[case testFunctionalEnumInClassBody]

from enum import Enum

class A:

E = Enum('E', 'a b')

class B:

E = Enum('E', 'a b')

x = A.E.a

y = B.E.a

if int():

x = y # E: Incompatible types in assignment (expression has type "__main__.B.E", variable has type "__main__.A.E")

[builtins fixtures/enum.pyi]

[case testFunctionalEnumProtocols]

from enum import IntEnum

Color = IntEnum('Color', 'red green blue')

reveal_type(Color['green']) # N: Revealed type is "__main__.Color"

for c in Color:

reveal_type(c) # N: Revealed type is "__main__.Color"

reveal_type(list(Color)) # N: Revealed type is "builtins.list[__main__.Color]"

[builtins fixtures/list.pyi]

[case testEnumWorkWithForward]

from enum import Enum

a: E = E.x # type: ignore[used-before-def]

class E(Enum):

x = 1

y = 2

[builtins fixtures/enum.pyi]

[out]

[case testEnumWorkWithForward2]

from enum import Enum

b: F

F = Enum('F', {'x': 1, 'y': 2})

def fn(x: F) -> None:

pass

fn(b)

[builtins fixtures/enum.pyi]

[out]

[case testFunctionalEnum]

# TODO: Needs to have enum34 stubs somehow

from enum import Enum

Eu = Enum(u'Eu', u'a b')

Eb = Enum(b'Eb', b'a b') # E: Enum() expects a string literal as the first argument

Gu = Enum(u'Gu', {u'a': 1})

Gb = Enum(b'Gb', {b'a': 1}) # E: Enum() expects a string literal as the first argument

Hu = Enum(u'Hu', [u'a'])

Hb = Enum(b'Hb', [b'a']) # E: Enum() expects a string literal as the first argument

Eu.a

Eb.a

Gu.a

Gb.a

Hu.a

Hb.a

[builtins fixtures/enum.pyi]

[out]

[case testEnumIncremental]

import m

reveal_type(m.E.a)

reveal_type(m.F.b)

[file m.py]

from enum import Enum

class E(Enum):

a = 1

b = 2

F = Enum('F', 'a b')

[builtins fixtures/enum.pyi]

[rechecked]

[stale]

[out1]

main:2: note: Revealed type is "Literal[m.E.a]?"

main:3: note: Revealed type is "Literal[m.F.b]?"

[out2]

main:2: note: Revealed type is "Literal[m.E.a]?"

main:3: note: Revealed type is "Literal[m.F.b]?"

[case testEnumAuto]

from enum import Enum, auto

class Test(Enum):

a = auto()

b = auto()

reveal_type(Test.a) # N: Revealed type is "Literal[__main__.Test.a]?"

[builtins fixtures/primitives.pyi]

[case testEnumAttributeAccessMatrix]

from enum import Enum, IntEnum, IntFlag, Flag, EnumMeta, auto

from typing import Literal

def is_x(val: Literal['x']) -> None: pass

A1 = Enum('A1', 'x')

class A2(Enum):

x = auto()

class A3(Enum):

x = 1

is_x(reveal_type(A1.x.name)) # N: Revealed type is "Literal['x']"

is_x(reveal_type(A1.x._name_)) # N: Revealed type is "Literal['x']"

reveal_type(A1.x.value) # N: Revealed type is "Any"

reveal_type(A1.x._value_) # N: Revealed type is "Any"

is_x(reveal_type(A2.x.name)) # N: Revealed type is "Literal['x']"

is_x(reveal_type(A2.x._name_)) # N: Revealed type is "Literal['x']"

reveal_type(A2.x.value) # N: Revealed type is "builtins.int"

reveal_type(A2.x._value_) # N: Revealed type is "builtins.int"

is_x(reveal_type(A3.x.name)) # N: Revealed type is "Literal['x']"

is_x(reveal_type(A3.x._name_)) # N: Revealed type is "Literal['x']"

reveal_type(A3.x.value) # N: Revealed type is "Literal[1]?"

reveal_type(A3.x._value_) # N: Revealed type is "Literal[1]?"

B1 = IntEnum('B1', 'x')

class B2(IntEnum):

x = auto()

class B3(IntEnum):

x = 1

is_x(reveal_type(B1.x.name)) # N: Revealed type is "Literal['x']"

is_x(reveal_type(B1.x._name_)) # N: Revealed type is "Literal['x']"

reveal_type(B1.x.value) # N: Revealed type is "builtins.int"

reveal_type(B1.x._value_) # N: Revealed type is "builtins.int"

is_x(reveal_type(B2.x.name)) # N: Revealed type is "Literal['x']"

is_x(reveal_type(B2.x._name_)) # N: Revealed type is "Literal['x']"

reveal_type(B2.x.value) # N: Revealed type is "builtins.int"

reveal_type(B2.x._value_) # N: Revealed type is "builtins.int"

is_x(reveal_type(B3.x.name)) # N: Revealed type is "Literal['x']"

is_x(reveal_type(B3.x._name_)) # N: Revealed type is "Literal['x']"

reveal_type(B3.x.value) # N: Revealed type is "Literal[1]?"

reveal_type(B3.x._value_) # N: Revealed type is "Literal[1]?"

C1 = IntFlag('C1', 'x')

class C2(IntFlag):

x = auto()

class C3(IntFlag):

x = 1

is_x(reveal_type(C1.x.name)) # N: Revealed type is "Literal['x']"

is_x(reveal_type(C1.x._name_)) # N: Revealed type is "Literal['x']"

reveal_type(C1.x.value) # N: Revealed type is "builtins.int"

reveal_type(C1.x._value_) # N: Revealed type is "builtins.int"

is_x(reveal_type(C2.x.name)) # N: Revealed type is "Literal['x']"

is_x(reveal_type(C2.x._name_)) # N: Revealed type is "Literal['x']"

reveal_type(C2.x.value) # N: Revealed type is "builtins.int"

reveal_type(C2.x._value_) # N: Revealed type is "builtins.int"

is_x(reveal_type(C3.x.name)) # N: Revealed type is "Literal['x']"

is_x(reveal_type(C3.x._name_)) # N: Revealed type is "Literal['x']"

reveal_type(C3.x.value) # N: Revealed type is "Literal[1]?"

reveal_type(C3.x._value_) # N: Revealed type is "Literal[1]?"

D1 = Flag('D1', 'x')

class D2(Flag):

x = auto()

class D3(Flag):

x = 1

is_x(reveal_type(D1.x.name)) # N: Revealed type is "Literal['x']"

is_x(reveal_type(D1.x._name_)) # N: Revealed type is "Literal['x']"

reveal_type(D1.x.value) # N: Revealed type is "builtins.int"

reveal_type(D1.x._value_) # N: Revealed type is "builtins.int"

is_x(reveal_type(D2.x.name)) # N: Revealed type is "Literal['x']"

is_x(reveal_type(D2.x._name_)) # N: Revealed type is "Literal['x']"

reveal_type(D2.x.value) # N: Revealed type is "builtins.int"

reveal_type(D2.x._value_) # N: Revealed type is "builtins.int"

is_x(reveal_type(D3.x.name)) # N: Revealed type is "Literal['x']"

is_x(reveal_type(D3.x._name_)) # N: Revealed type is "Literal['x']"

reveal_type(D3.x.value) # N: Revealed type is "Literal[1]?"

reveal_type(D3.x._value_) # N: Revealed type is "Literal[1]?"

# TODO: Generalize our enum functional API logic to work with subclasses of Enum

# See https://github.com/python/mypy/issues/6037

class Parent(Enum): pass

# E1 = Parent('E1', 'x') # See above TODO

class E2(Parent):

x = auto()

class E3(Parent):

x = 1

is_x(reveal_type(E2.x.name)) # N: Revealed type is "Literal['x']"

is_x(reveal_type(E2.x._name_)) # N: Revealed type is "Literal['x']"

reveal_type(E2.x.value) # N: Revealed type is "builtins.int"

reveal_type(E2.x._value_) # N: Revealed type is "builtins.int"

is_x(reveal_type(E3.x.name)) # N: Revealed type is "Literal['x']"

is_x(reveal_type(E3.x._name_)) # N: Revealed type is "Literal['x']"

reveal_type(E3.x.value) # N: Revealed type is "Literal[1]?"

reveal_type(E3.x._value_) # N: Revealed type is "Literal[1]?"

# TODO: Figure out if we can construct enums using EnumMetas using the functional API.

# Also figure out if we even care about supporting that use case.

class F2(metaclass=EnumMeta):

x = auto()

class F3(metaclass=EnumMeta):

x = 1

F2.x.name # E: "F2" has no attribute "name"

F2.x._name_ # E: "F2" has no attribute "_name_"

F2.x.value # E: "F2" has no attribute "value"

F2.x._value_ # E: "F2" has no attribute "_value_"

F3.x.name # E: "F3" has no attribute "name"

F3.x._name_ # E: "F3" has no attribute "_name_"

F3.x.value # E: "F3" has no attribute "value"

F3.x._value_ # E: "F3" has no attribute "_value_"

[builtins fixtures/primitives.pyi]

[case testEnumAttributeChangeIncremental]

from a import SomeEnum

reveal_type(SomeEnum.a.value)

[file a.py]

from b import SomeEnum

[file b.py]

from enum import Enum

class SomeEnum(Enum):

a = 1

[file b.py.2]

from enum import Enum

class SomeEnum(Enum):

a = "foo"

[builtins fixtures/enum.pyi]

[out]

main:2: note: Revealed type is "Literal[1]?"

[out2]

main:2: note: Revealed type is "Literal['foo']?"

[case testEnumReachabilityChecksBasic]

# flags: --warn-unreachable

from enum import Enum

from typing import Literal

class Foo(Enum):

A = 1

B = 2

C = 3

x: Literal[Foo.A, Foo.B, Foo.C]

if x is Foo.A:

reveal_type(x) # N: Revealed type is "Literal[__main__.Foo.A]"

elif x is Foo.B:

reveal_type(x) # N: Revealed type is "Literal[__main__.Foo.B]"

elif x is Foo.C:

reveal_type(x) # N: Revealed type is "Literal[__main__.Foo.C]"

else:

reveal_type(x) # E: Statement is unreachable

reveal_type(x) # N: Revealed type is "Literal[__main__.Foo.A] | Literal[__main__.Foo.B] | Literal[__main__.Foo.C]"

if Foo.A is x:

reveal_type(x) # N: Revealed type is "Literal[__main__.Foo.A]"

elif Foo.B is x:

reveal_type(x) # N: Revealed type is "Literal[__main__.Foo.B]"

elif Foo.C is x:

reveal_type(x) # N: Revealed type is "Literal[__main__.Foo.C]"

else:

reveal_type(x) # E: Statement is unreachable

reveal_type(x) # N: Revealed type is "Literal[__main__.Foo.A] | Literal[__main__.Foo.B] | Literal[__main__.Foo.C]"

y: Foo

if y is Foo.A:

reveal_type(y) # N: Revealed type is "Literal[__main__.Foo.A]"

elif y is Foo.B:

reveal_type(y) # N: Revealed type is "Literal[__main__.Foo.B]"

elif y is Foo.C:

reveal_type(y) # N: Revealed type is "Literal[__main__.Foo.C]"

else:

reveal_type(y) # E: Statement is unreachable

reveal_type(y) # N: Revealed type is "__main__.Foo"

if Foo.A is y:

reveal_type(y) # N: Revealed type is "Literal[__main__.Foo.A]"

elif Foo.B is y:

reveal_type(y) # N: Revealed type is "Literal[__main__.Foo.B]"

elif Foo.C is y:

reveal_type(y) # N: Revealed type is "Literal[__main__.Foo.C]"

else:

reveal_type(y) # E: Statement is unreachable

reveal_type(y) # N: Revealed type is "__main__.Foo"

[builtins fixtures/bool.pyi]

[case testEnumReachabilityChecksWithOrdering]

# flags: --warn-unreachable

from enum import Enum

from typing import Literal

class Foo(Enum):

_order_ = "A B"

A = 1

B = 2

Foo._order_ # E: "type[Foo]" has no attribute "_order_"

x: Literal[Foo.A, Foo.B]

if x is Foo.A:

reveal_type(x) # N: Revealed type is "Literal[__main__.Foo.A]"

elif x is Foo.B:

reveal_type(x) # N: Revealed type is "Literal[__main__.Foo.B]"

else:

reveal_type(x) # E: Statement is unreachable

class Bar(Enum):

__order__ = "A B"

A = 1

B = 2

Bar.__order__ # E: "type[Bar]" has no attribute "__order__"

y: Literal[Bar.A, Bar.B]

if y is Bar.A:

reveal_type(y) # N: Revealed type is "Literal[__main__.Bar.A]"

elif y is Bar.B:

reveal_type(y) # N: Revealed type is "Literal[__main__.Bar.B]"

else:

reveal_type(y) # E: Statement is unreachable

x2: Foo

if x2 is Foo.A:

reveal_type(x2) # N: Revealed type is "Literal[__main__.Foo.A]"

elif x2 is Foo.B:

reveal_type(x2) # N: Revealed type is "Literal[__main__.Foo.B]"

else:

reveal_type(x2) # E: Statement is unreachable

y2: Bar

if y2 is Bar.A:

reveal_type(y2) # N: Revealed type is "Literal[__main__.Bar.A]"

elif y2 is Bar.B:

reveal_type(y2) # N: Revealed type is "Literal[__main__.Bar.B]"

else:

reveal_type(y2) # E: Statement is unreachable

[builtins fixtures/tuple.pyi]

[case testEnumReachabilityChecksIndirect]

# flags: --warn-unreachable

from enum import Enum

from typing import Final, Literal

class Foo(Enum):

A = 1

B = 2

C = 3

def accepts_foo_a(x: Literal[Foo.A]) -> None: ...

x: Foo

y: Literal[Foo.A]

z: Final = Foo.A

if x is y:

reveal_type(x) # N: Revealed type is "Literal[__main__.Foo.A]"

reveal_type(y) # N: Revealed type is "Literal[__main__.Foo.A]"

else:

reveal_type(x) # N: Revealed type is "Literal[__main__.Foo.B] | Literal[__main__.Foo.C]"

reveal_type(y) # N: Revealed type is "Literal[__main__.Foo.A]"

reveal_type(x) # N: Revealed type is "__main__.Foo"

if y is x:

reveal_type(x) # N: Revealed type is "Literal[__main__.Foo.A]"

reveal_type(y) # N: Revealed type is "Literal[__main__.Foo.A]"

else:

reveal_type(x) # N: Revealed type is "Literal[__main__.Foo.B] | Literal[__main__.Foo.C]"