[red-knot] Literal special form (#13874)

Handling `Literal` type in annotations.

Resolves: #13672 

## Implementation

Since Literals are not a fully defined type in typeshed. I used a trick
to figure out when a special form is a literal.
When we are inferring assignment types I am checking if the type of that
assignment was resolved to typing.SpecialForm and the name of the target
is `Literal` if that is the case then I am re creating a new instance
type and set the known instance field to `KnownInstance:Literal`.

**Why not defining a new type?**

From this [issue](https://github.com/python/typeshed/issues/6219) I
learned that we want to resolve members to SpecialMethod class. So if we
create a new instance here we can rely on the member resolving in that
already exists.


## Tests


https://typing.readthedocs.io/en/latest/spec/literal.html#equivalence-of-two-literals
Since the type of the value inside Literal is evaluated as a
Literal(LiteralString, LiteralInt, ...) then the equality is only true
when types and value are equal.


https://typing.readthedocs.io/en/latest/spec/literal.html#legal-and-illegal-parameterizations

The illegal parameterizations are mostly implemented I'm currently
checking the slice expression and the slice type to make sure it's
valid.

https://typing.readthedocs.io/en/latest/spec/literal.html#shortening-unions-of-literals

---------

Co-authored-by: Carl Meyer <carl@astral.sh>
Co-authored-by: Alex Waygood <Alex.Waygood@Gmail.com>

crates/red_knot_python_semantic/resources/mdtest/comparison/instances/membership_test.md

@@ -93,13 +93,11 @@ class AlwaysFalse:
     def __contains__(self, item: int) -> Literal[""]:
         return ""
 
-# TODO: it should be Literal[True] and Literal[False]
-reveal_type(42 in AlwaysTrue())  # revealed: @Todo
-reveal_type(42 not in AlwaysTrue())  # revealed: @Todo
+reveal_type(42 in AlwaysTrue())  # revealed: Literal[True]
+reveal_type(42 not in AlwaysTrue())  # revealed: Literal[False]
 
-# TODO: it should be Literal[False] and Literal[True]
-reveal_type(42 in AlwaysFalse())  # revealed: @Todo
-reveal_type(42 not in AlwaysFalse())  # revealed: @Todo
+reveal_type(42 in AlwaysFalse())  # revealed: Literal[False]
+reveal_type(42 not in AlwaysFalse())  # revealed: Literal[True]
 ```
 
 ## No Fallback for `__contains__`

crates/red_knot_python_semantic/resources/mdtest/literal/literal.md

@@ -0,0 +1,91 @@
+# Literal
+
+<https://typing.readthedocs.io/en/latest/spec/literal.html#literals>
+
+## Parameterization
+
+```py
+from typing import Literal
+from enum import Enum
+
+mode: Literal["w", "r"]
+mode2: Literal["w"] | Literal["r"]
+union_var: Literal[Literal[Literal[1, 2, 3], "foo"], 5, None]
+a1: Literal[26]
+a2: Literal[0x1A]
+a3: Literal[-4]
+a4: Literal["hello world"]
+a5: Literal[b"hello world"]
+a6: Literal[True]
+a7: Literal[None]
+a8: Literal[Literal[1]]
+a9: Literal[Literal["w"], Literal["r"], Literal[Literal["w+"]]]
+
+class Color(Enum):
+    RED = 0
+    GREEN = 1
+    BLUE = 2
+
+b1: Literal[Color.RED]
+
+def f():
+    reveal_type(mode)  # revealed: Literal["w", "r"]
+    reveal_type(mode2)  # revealed: Literal["w", "r"]
+    # TODO: should be revealed: Literal[1, 2, 3, "foo", 5] | None
+    reveal_type(union_var)  # revealed: Literal[1, 2, 3, 5] | Literal["foo"] | None
+    reveal_type(a1)  # revealed: Literal[26]
+    reveal_type(a2)  # revealed: Literal[26]
+    reveal_type(a3)  # revealed: Literal[-4]
+    reveal_type(a4)  # revealed: Literal["hello world"]
+    reveal_type(a5)  # revealed: Literal[b"hello world"]
+    reveal_type(a6)  # revealed: Literal[True]
+    reveal_type(a7)  # revealed: None
+    reveal_type(a8)  # revealed: Literal[1]
+    reveal_type(a9)  # revealed: Literal["w", "r", "w+"]
+    # TODO: This should be Color.RED
+    reveal_type(b1)  # revealed: Literal[0]
+
+# error: [invalid-literal-parameter]
+invalid1: Literal[3 + 4]
+# error: [invalid-literal-parameter]
+invalid2: Literal[4 + 3j]
+# error: [invalid-literal-parameter]
+invalid3: Literal[(3, 4)]
+invalid4: Literal[
+    1 + 2,  # error: [invalid-literal-parameter]
+    "foo",
+    hello,  # error: [invalid-literal-parameter]
+    (1, 2, 3),  # error: [invalid-literal-parameter]
+]
+```
+
+## Detecting Literal outside typing and typing_extensions
+
+Only Literal that is defined in typing and typing_extension modules is detected as the special
+Literal.
+
+```pyi path=other.pyi
+from typing import _SpecialForm
+
+Literal: _SpecialForm
+```
+
+```py
+from other import Literal
+
+a1: Literal[26]
+
+def f():
+    reveal_type(a1)  # revealed: @Todo
+```
+
+## Detecting typing_extensions.Literal
+
+```py
+from typing_extensions import Literal
+
+a1: Literal[26]
+
+def f():
+    reveal_type(a1)  # revealed: Literal[26]
+```

crates/red_knot_python_semantic/resources/mdtest/unary/instance.md

@@ -1,6 +1,8 @@
 # Unary Operations
 
 ```py
+from typing import Literal
+
 class Number:
     def __init__(self, value: int):
         self.value = 1
@@ -18,7 +20,7 @@ a = Number()
 
 reveal_type(+a)  # revealed: int
 reveal_type(-a)  # revealed: int
-reveal_type(~a)  # revealed: @Todo
+reveal_type(~a)  # revealed: Literal[True]
 
 class NoDunder: ...