Consider code (in attachment) that is being run on Python 3.9.
An expected output of such code ought to be:

(typing_extensions.Literal[1], typing_extensions.Literal[0]) (typing_extensions.Literal[True], typing_extensions.Literal[False])

However that's not the case. An output of the code, given that A is declared first, will be:

(typing.Literal[1], typing.Literal[0]) (typing.Literal[1], typing.Literal[0])

and if B is declared first we receive:

(typing.Literal[True], typing.Literal[False]) (typing.Literal[True], typing.Literal[False])

I believe a reason for that is having `bool` as subclass of `int` and consecutively having `typing._tp_cache` function that declares untyped cache. Indeed changing `cached = functools.lru_cache()(func)` to `cached = functools.lru_cache(typed=True)(func)` makes the linked code immune to A and B deceleration order.

Also happens in `3.8`, so right when `Literal` got moved to core `Python`.

No need to open the attachment -- a simpler repro is:

>>> from typing import Literal
>>> Literal[1]
typing.Literal[1]
>>> Literal[True]
typing.Literal[1]
>>> 

However, in a fresh session

>>> from typing import Literal
>>> Literal[True]
typing.Literal[True]
>>> 

This must be because there's a cache in typing.py that use == but doesn't check the type. We can demonstrate that this is the case using a similar equivalence between 2.0 and 2:

>>> Literal[2.0]
typing.Literal[2.0]
>>> Literal[2]
typing.Literal[2.0]
>>> 

It looks like the function _tp_cache() is the culprit -- it uses functools.lru_cache() which apparently uses simple equality.

def _tp_cache(func):
    """..."""
    cached = functools.lru_cache()(func)
    _cleanups.append(cached.cache_clear)

    @functools.wraps(func)
    def inner(*args, **kwds):
        try:
            return cached(*args, **kwds)
        except TypeError:
            pass  # All real errors (not unhashable args) are raised below.
        return func(*args, **kwds)
    return inner

Here's a confusing demo:

>> @functools.lru_cache()
... def f(a): return a
... 
>>> f(1)
1
>>> f(True)
True
>>> f(1)
1
>>> f(1.0)
True
>>> 

(Confusing because it distinguishes between 1 and True, unlike Literal, but it then maps 1.0 to True.)

However a possible fix might be to add typed=True to the functools.lru_cache() call in typing.py, which should have the desired effect (not tested).

I will play around and maybe submit PR later this evening.

In the PR (https://github.com/python/cpython/pull/17974) we found that there's no great solution for this. This issue will probably linger for a while, but maybe we should just set an example and close it, since we're unlikely to take any action?