Rename Red Knot (#17820)

crates/ty_python_semantic/resources/mdtest/assignment/annotations.md

@@ -0,0 +1,138 @@
+# Assignment with annotations
+
+## Annotation only transparent to local inference
+
+```py
+x = 1
+x: int
+y = x
+
+reveal_type(y)  # revealed: Literal[1]
+```
+
+## Violates own annotation
+
+```py
+x: int = "foo"  # error: [invalid-assignment] "Object of type `Literal["foo"]` is not assignable to `int`"
+```
+
+## Violates previous annotation
+
+```py
+x: int
+x = "foo"  # error: [invalid-assignment] "Object of type `Literal["foo"]` is not assignable to `int`"
+```
+
+## Tuple annotations are understood
+
+```toml
+[environment]
+python-version = "3.12"
+```
+
+`module.py`:
+
+```py
+from typing_extensions import Unpack
+
+a: tuple[()] = ()
+b: tuple[int] = (42,)
+c: tuple[str, int] = ("42", 42)
+d: tuple[tuple[str, str], tuple[int, int]] = (("foo", "foo"), (42, 42))
+e: tuple[str, ...] = ()
+f: tuple[str, *tuple[int, ...], bytes] = ("42", b"42")
+g: tuple[str, Unpack[tuple[int, ...]], bytes] = ("42", b"42")
+h: tuple[list[int], list[int]] = ([], [])
+i: tuple[str | int, str | int] = (42, 42)
+j: tuple[str | int] = (42,)
+```
+
+`script.py`:
+
+```py
+from module import a, b, c, d, e, f, g, h, i, j
+
+reveal_type(a)  # revealed: tuple[()]
+reveal_type(b)  # revealed: tuple[int]
+reveal_type(c)  # revealed: tuple[str, int]
+reveal_type(d)  # revealed: tuple[tuple[str, str], tuple[int, int]]
+
+# TODO: homogeneous tuples, PEP-646 tuples, generics
+reveal_type(e)  # revealed: @Todo(full tuple[...] support)
+reveal_type(f)  # revealed: @Todo(full tuple[...] support)
+reveal_type(g)  # revealed: @Todo(full tuple[...] support)
+reveal_type(h)  # revealed: tuple[@Todo(specialized non-generic class), @Todo(specialized non-generic class)]
+
+reveal_type(i)  # revealed: tuple[str | int, str | int]
+reveal_type(j)  # revealed: tuple[str | int]
+```
+
+## Incorrect tuple assignments are complained about
+
+```py
+# error: [invalid-assignment] "Object of type `tuple[Literal[1], Literal[2]]` is not assignable to `tuple[()]`"
+a: tuple[()] = (1, 2)
+
+# error: [invalid-assignment] "Object of type `tuple[Literal["foo"]]` is not assignable to `tuple[int]`"
+b: tuple[int] = ("foo",)
+
+# error: [invalid-assignment] "Object of type `tuple[list, Literal["foo"]]` is not assignable to `tuple[str | int, str]`"
+c: tuple[str | int, str] = ([], "foo")
+```
+
+## PEP-604 annotations are supported
+
+```py
+def foo(v: str | int | None, w: str | str | None, x: str | str):
+    reveal_type(v)  # revealed: str | int | None
+    reveal_type(w)  # revealed: str | None
+    reveal_type(x)  # revealed: str
+```
+
+## Attribute expressions in type annotations are understood
+
+```py
+import builtins
+
+int = "foo"
+a: builtins.int = 42
+
+# error: [invalid-assignment] "Object of type `Literal["bar"]` is not assignable to `int`"
+b: builtins.int = "bar"
+
+c: builtins.tuple[builtins.tuple[builtins.int, builtins.int], builtins.int] = ((42, 42), 42)
+
+# error: [invalid-assignment] "Object of type `Literal["foo"]` is not assignable to `tuple[tuple[int, int], int]`"
+c: builtins.tuple[builtins.tuple[builtins.int, builtins.int], builtins.int] = "foo"
+```
+
+## Future annotations are deferred
+
+```py
+from __future__ import annotations
+
+x: Foo
+
+class Foo: ...
+
+x = Foo()
+reveal_type(x)  # revealed: Foo
+```
+
+## Annotations in stub files are deferred
+
+```pyi
+x: Foo
+
+class Foo: ...
+
+x = Foo()
+reveal_type(x)  # revealed: Foo
+```
+
+## Annotated assignments in stub files are inferred correctly
+
+```pyi
+x: int = 1
+reveal_type(x) # revealed: Literal[1]
+```

crates/ty_python_semantic/resources/mdtest/assignment/augmented.md

@@ -0,0 +1,182 @@
+# Augmented assignment
+
+## Basic
+
+```py
+x = 3
+x -= 1
+reveal_type(x)  # revealed: Literal[2]
+
+x = 1.0
+x /= 2
+reveal_type(x)  # revealed: int | float
+
+x = (1, 2)
+x += (3, 4)
+reveal_type(x)  # revealed: tuple[Literal[1], Literal[2], Literal[3], Literal[4]]
+```
+
+## Dunder methods
+
+```py
+class C:
+    def __isub__(self, other: int) -> str:
+        return "Hello, world!"
+
+x = C()
+x -= 1
+reveal_type(x)  # revealed: str
+
+class C:
+    def __iadd__(self, other: str) -> int:
+        return 1
+
+x = C()
+x += "Hello"
+reveal_type(x)  # revealed: int
+```
+
+## Unsupported types
+
+```py
+class C:
+    def __isub__(self, other: str) -> int:
+        return 42
+
+x = C()
+# error: [unsupported-operator] "Operator `-=` is unsupported between objects of type `C` and `Literal[1]`"
+x -= 1
+
+reveal_type(x)  # revealed: int
+```
+
+## Method union
+
+```py
+def _(flag: bool):
+    class Foo:
+        if flag:
+            def __iadd__(self, other: int) -> str:
+                return "Hello, world!"
+        else:
+            def __iadd__(self, other: int) -> int:
+                return 42
+
+    f = Foo()
+    f += 12
+
+    reveal_type(f)  # revealed: str | int
+```
+
+## Partially bound `__iadd__`
+
+```py
+def _(flag: bool):
+    class Foo:
+        if flag:
+            def __iadd__(self, other: str) -> int:
+                return 42
+
+    f = Foo()
+
+    # error: [unsupported-operator] "Operator `+=` is unsupported between objects of type `Foo` and `Literal["Hello, world!"]`"
+    f += "Hello, world!"
+
+    reveal_type(f)  # revealed: int | Unknown
+```
+
+## Partially bound with `__add__`
+
+```py
+def _(flag: bool):
+    class Foo:
+        def __add__(self, other: str) -> str:
+            return "Hello, world!"
+        if flag:
+            def __iadd__(self, other: str) -> int:
+                return 42
+
+    f = Foo()
+    f += "Hello, world!"
+
+    reveal_type(f)  # revealed: int | str
+```
+
+## Partially bound target union
+
+```py
+def _(flag1: bool, flag2: bool):
+    class Foo:
+        def __add__(self, other: int) -> str:
+            return "Hello, world!"
+        if flag1:
+            def __iadd__(self, other: int) -> int:
+                return 42
+
+    if flag2:
+        f = Foo()
+    else:
+        f = 42.0
+    f += 12
+
+    reveal_type(f)  # revealed: int | str | float
+```
+
+## Target union
+
+```py
+def _(flag: bool):
+    class Foo:
+        def __iadd__(self, other: int) -> str:
+            return "Hello, world!"
+
+    if flag:
+        f = Foo()
+    else:
+        f = 42
+    f += 12
+
+    reveal_type(f)  # revealed: str | Literal[54]
+```
+
+## Partially bound target union with `__add__`
+
+```py
+def f(flag: bool, flag2: bool):
+    class Foo:
+        def __add__(self, other: int) -> str:
+            return "Hello, world!"
+        if flag:
+            def __iadd__(self, other: int) -> int:
+                return 42
+
+    class Bar:
+        def __add__(self, other: int) -> bytes:
+            return b"Hello, world!"
+
+        def __iadd__(self, other: int) -> float:
+            return 42.0
+
+    if flag2:
+        f = Foo()
+    else:
+        f = Bar()
+    f += 12
+
+    reveal_type(f)  # revealed: int | str | float
+```
+
+## Implicit dunder calls on class objects
+
+```py
+class Meta(type):
+    def __iadd__(cls, other: int) -> str:
+        return ""
+
+class C(metaclass=Meta): ...
+
+cls = C
+cls += 1
+
+reveal_type(cls)  # revealed: str
+```

crates/ty_python_semantic/resources/mdtest/assignment/multi_target.md

@@ -0,0 +1,9 @@
+# Multi-target assignment
+
+## Basic
+
+```py
+x = y = 1
+reveal_type(x)  # revealed: Literal[1]
+reveal_type(y)  # revealed: Literal[1]
+```

crates/ty_python_semantic/resources/mdtest/assignment/unbound.md

@@ -0,0 +1,20 @@
+# Unbound
+
+## Unbound
+
+```py
+x = foo  # error: [unresolved-reference] "Name `foo` used when not defined"
+foo = 1
+
+# No error `unresolved-reference` diagnostic is reported for `x`. This is
+# desirable because we would get a lot of cascading errors even though there
+# is only one root cause (the unbound variable `foo`).
+
+# revealed: Unknown
+reveal_type(x)
+```
+
+Note: in this particular example, one could argue that the most likely error would be a wrong order
+of the `x`/`foo` definitions, and so it could be desirable to infer `Literal[1]` for the type of
+`x`. On the other hand, there might be a variable `fob` a little higher up in this file, and the
+actual error might have been just a typo. Inferring `Unknown` thus seems like the safest option.

crates/ty_python_semantic/resources/mdtest/assignment/walrus.md

@@ -0,0 +1,17 @@
+# Walrus operator
+
+## Basic
+
+```py
+x = (y := 1) + 1
+reveal_type(x)  # revealed: Literal[2]
+reveal_type(y)  # revealed: Literal[1]
+```
+
+## Walrus self-addition
+
+```py
+x = 0
+(x := x + 1)
+reveal_type(x)  # revealed: Literal[1]
+```