[red-knot] Format mdtest Python snippets more concisely (#13905)

.pre-commit-config.yaml

@@ -46,10 +46,10 @@ repos:
           )$
 
   - repo: https://github.com/adamchainz/blacken-docs
-    rev: 1.19.0
+    rev: 1.19.1
     hooks:
       - id: blacken-docs
-        args: ["--line-length", "130"]
+        args: ["--pyi", "--line-length", "130"]
         files: '^crates/.*/resources/mdtest/.*\.md'
         additional_dependencies:
           - black==24.10.0

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

@@ -15,13 +15,11 @@ Name lookups within a class scope fall back to globals, but lookups of class att
 ```py
 x = 1
 
-
 class C:
     y = x
     if flag:
         x = 2
 
-
 reveal_type(C.x)  # revealed: Literal[2]
 reveal_type(C.y)  # revealed: Literal[1]
 ```

crates/red_knot_python_semantic/resources/mdtest/attributes.md

@@ -4,15 +4,12 @@
 
 ```py
 if flag:
-
     class C:
         x = 1
 
 else:
-
     class C:
         x = 2
 
-
 reveal_type(C.x)  # revealed: Literal[1, 2]
 ```

crates/red_knot_python_semantic/resources/mdtest/binary/instances.md

@@ -53,10 +53,8 @@ class A:
     def __or__(self, other) -> A:
         return self
 
-
 class B: ...
 
-
 reveal_type(A() + B())  # revealed: A
 reveal_type(A() - B())  # revealed: A
 reveal_type(A() * B())  # revealed: A
@@ -117,10 +115,8 @@ class A:
     def __ror__(self, other) -> A:
         return self
 
-
 class B: ...
 
-
 reveal_type(B() + A())  # revealed: A
 reveal_type(B() - A())  # revealed: A
 reveal_type(B() * A())  # revealed: A
@@ -148,10 +144,8 @@ class A:
     def __rsub__(self, other) -> int:
         return 1
 
-
 class B: ...
 
-
 reveal_type(A() + B())  # revealed: int
 reveal_type(B() - A())  # revealed: int
 ```
@@ -167,15 +161,12 @@ class A:
     def __add__(self, other: B) -> int:
         return 42
 
-
 class B:
     def __radd__(self, other: A) -> str:
         return "foo"
 
-
 reveal_type(A() + B())  # revealed:  int
 
-
 # Edge case: C is a subtype of C, *but* if the two sides are of *equal* types,
 # the lhs *still* takes precedence
 class C:
@@ -185,7 +176,6 @@ class C:
     def __radd__(self, other: C) -> str:
         return "foo"
 
-
 reveal_type(C() + C())  # revealed: int
 ```
 
@@ -203,22 +193,17 @@ class A:
     def __radd__(self, other) -> str:
         return "foo"
 
-
 class MyString(str): ...
 
-
 class B(A):
     def __radd__(self, other) -> MyString:
         return MyString()
 
-
 reveal_type(A() + B())  # revealed: MyString
 
-
 # N.B. Still a subtype of `A`, even though `A` does not appear directly in the class's `__bases__`
 class C(B): ...
 
-
 # TODO: we currently only understand direct subclasses as subtypes of the superclass.
 # We need to iterate through the full MRO rather than just the class's bases;
 # if we do, we'll understand `C` as a subtype of `A`, and correctly understand this as being
@@ -240,10 +225,8 @@ class A:
     def __radd__(self, other) -> int:
         return 42
 
-
 class B(A): ...
 
-
 reveal_type(A() + B())  # revealed: str
 ```
 
@@ -266,12 +249,10 @@ class A:
     def __sub__(self, other: A) -> A:
         return A()
 
-
 class B:
     def __rsub__(self, other: A) -> B:
         return B()
 
-
 # TODO: this should be `B` (the return annotation of `B.__rsub__`),
 # because `A.__sub__` is annotated as only accepting `A`,
 # but `B.__rsub__` will accept `A`.
@@ -287,11 +268,9 @@ class A:
     def __call__(self, other) -> int:
         return 42
 
-
 class B:
     __add__ = A()
 
-
 reveal_type(B() + B())  # revealed: int
 ```
 
@@ -311,15 +290,12 @@ reveal_type(42 + 4.2)  # revealed: int
 # TODO should be complex, need to check arg type and fall back to `rhs.__radd__`
 reveal_type(3 + 3j)  # revealed: int
 
-
 def returns_int() -> int:
     return 42
 
-
 def returns_bool() -> bool:
     return True
 
-
 x = returns_bool()
 y = returns_int()
 
@@ -343,7 +319,6 @@ class A:
     def __radd__(self, other) -> A:
         return self
 
-
 reveal_type(A() + 1)  # revealed: A
 # TODO should be `A` since `int.__add__` doesn't support `A` instances
 reveal_type(1 + A())  # revealed: int
@@ -388,15 +363,12 @@ from does_not_exist import Foo  # error: [unresolved-import]
 
 reveal_type(Foo)  # revealed: Unknown
 
-
 class X:
     def __add__(self, other: object) -> int:
         return 42
 
-
 class Y(Foo): ...
 
-
 # TODO: Should be `int | Unknown`; see above discussion.
 reveal_type(X() + Y())  # revealed: int
 ```
@@ -411,12 +383,10 @@ The magic method must exist on the class, not just on the instance:
 def add_impl(self, other) -> int:
     return 1
 
-
 class A:
     def __init__(self):
         self.__add__ = add_impl
 
-
 # error: [unsupported-operator] "Operator `+` is unsupported between objects of type `A` and `A`"
 # revealed: Unknown
 reveal_type(A() + A())
@@ -427,7 +397,6 @@ reveal_type(A() + A())
 ```py
 class A: ...
 
-
 # error: [unsupported-operator]
 # revealed: Unknown
 reveal_type(A() + A())
@@ -441,14 +410,11 @@ A left-hand dunder method doesn't apply for the right-hand operand, or vice vers
 class A:
     def __add__(self, other) -> int: ...
 
-
 class B:
     def __radd__(self, other) -> int: ...
 
-
 class C: ...
 
-
 # error: [unsupported-operator]
 # revealed: Unknown
 reveal_type(C() + A())
@@ -471,7 +437,6 @@ class Foo:
     def __radd__(self, other: Foo) -> Foo:
         return self
 
-
 # error: [unsupported-operator]
 # revealed: Unknown
 reveal_type(Foo() + Foo())

crates/red_knot_python_semantic/resources/mdtest/binary/integers.md

@@ -62,10 +62,8 @@ bool(1) / False
 # revealed: float
 reveal_type(1.0 / 0)
 
-
 class MyInt(int): ...
 
-
 # No error for a subclass of int
 # revealed: float
 reveal_type(MyInt(3) / 0)

crates/red_knot_python_semantic/resources/mdtest/call/callable_instance.md

@@ -10,14 +10,11 @@ class Multiplier:
     def __call__(self, number: float) -> float:
         return number * self.factor
 
-
 a = Multiplier(2.0)(3.0)
 reveal_type(a)  # revealed: float
 
-
 class Unit: ...
 
-
 b = Unit()(3.0)  # error: "Object of type `Unit` is not callable"
 reveal_type(b)  # revealed: Unknown
 ```

crates/red_knot_python_semantic/resources/mdtest/call/constructor.md

@@ -3,6 +3,5 @@
 ```py
 class Foo: ...
 
-
 reveal_type(Foo())  # revealed: Foo
 ```

crates/red_knot_python_semantic/resources/mdtest/call/function.md

@@ -6,7 +6,6 @@
 def get_int() -> int:
     return 42
 
-
 reveal_type(get_int())  # revealed: int
 ```
 
@@ -16,7 +15,6 @@ reveal_type(get_int())  # revealed: int
 async def get_int_async() -> int:
     return 42
 
-
 # TODO: we don't yet support `types.CoroutineType`, should be generic `Coroutine[Any, Any, int]`
 reveal_type(get_int_async())  # revealed: @Todo
 ```
@@ -26,20 +24,16 @@ reveal_type(get_int_async())  # revealed: @Todo
 ```py
 from typing import Callable
 
-
 def foo() -> int:
     return 42
 
-
 def decorator(func) -> Callable[[], int]:
     return foo
 
-
 @decorator
 def bar() -> str:
     return "bar"
 
-
 # TODO: should reveal `int`, as the decorator replaces `bar` with `foo`
 reveal_type(bar())  # revealed: @Todo
 ```

crates/red_knot_python_semantic/resources/mdtest/call/union.md

@@ -13,7 +13,6 @@ else:
     def f() -> str:
         return "foo"
 
-
 reveal_type(f())  # revealed: int | str
 ```
 
@@ -27,7 +26,6 @@ if flag:
     def f() -> int:
         return 1
 
-
 reveal_type(f())  # revealed: Unknown | int
 ```
 
@@ -43,7 +41,6 @@ else:
     def f() -> int:
         return 1
 
-
 x = f()  # error: "Object of type `Literal[1] | Literal[f]` is not callable (due to union element `Literal[1]`)"
 reveal_type(x)  # revealed: Unknown | int
 ```
@@ -62,7 +59,6 @@ else:
     def f() -> int:
         return 1
 
-
 # error: "Object of type `Literal[1] | Literal["foo"] | Literal[f]` is not callable (due to union elements Literal[1], Literal["foo"])"
 # revealed: Unknown | int
 reveal_type(f())

crates/red_knot_python_semantic/resources/mdtest/comparison/integers.md

@@ -21,7 +21,6 @@ reveal_type(1 <= "" and 0 < 1)  # revealed: @Todo | Literal[True]
 # TODO: implement lookup of `__eq__` on typeshed `int` stub.
 def int_instance() -> int: ...
 
-
 reveal_type(1 == int_instance())  # revealed: @Todo
 reveal_type(9 < int_instance())  # revealed: bool
 reveal_type(int_instance() < int_instance())  # revealed: bool

crates/red_knot_python_semantic/resources/mdtest/comparison/non_boolean_returns.md

@@ -21,15 +21,15 @@ Walking through examples:
 ```py
 from __future__ import annotations
 
-
 class A:
     def __lt__(self, other) -> A: ...
+
 class B:
     def __lt__(self, other) -> B: ...
+
 class C:
     def __lt__(self, other) -> C: ...
 
-
 x = A() < B() < C()
 reveal_type(x)  # revealed: A | B
 

crates/red_knot_python_semantic/resources/mdtest/comparison/strings.md

@@ -5,7 +5,6 @@
 ```py
 def str_instance() -> str: ...
 
-
 reveal_type("abc" == "abc")  # revealed: Literal[True]
 reveal_type("ab_cd" <= "ab_ce")  # revealed: Literal[True]
 reveal_type("abc" in "ab cd")  # revealed: Literal[False]