Don't special-case class instances in binary expression inference

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

@@ -46,3 +46,50 @@ reveal_type(a | b)  # revealed: Literal[True]
 reveal_type(b | a)  # revealed: Literal[True]
 reveal_type(b | b)  # revealed: Literal[False]
 ```
+
+## Arithmetic with a variable
+
+```py
+a = True
+b = False
+
+def lhs_is_int(x: int):
+    reveal_type(x + a)  # revealed: int
+    reveal_type(x - a)  # revealed: int
+    reveal_type(x * a)  # revealed: int
+    reveal_type(x // a)  # revealed: int
+    reveal_type(x / a)  # revealed: float
+    reveal_type(x % a)  # revealed: int
+
+def rhs_is_int(x: int):
+    reveal_type(a + x)  # revealed: int
+    reveal_type(a - x)  # revealed: int
+    reveal_type(a * x)  # revealed: int
+    reveal_type(a // x)  # revealed: int
+    reveal_type(a / x)  # revealed: float
+    reveal_type(a % x)  # revealed: int
+
+def lhs_is_bool(x: bool):
+    reveal_type(x + a)  # revealed: int
+    reveal_type(x - a)  # revealed: int
+    reveal_type(x * a)  # revealed: int
+    reveal_type(x // a)  # revealed: int
+    reveal_type(x / a)  # revealed: float
+    reveal_type(x % a)  # revealed: int
+
+def rhs_is_bool(x: bool):
+    reveal_type(a + x)  # revealed: int
+    reveal_type(a - x)  # revealed: int
+    reveal_type(a * x)  # revealed: int
+    reveal_type(a // x)  # revealed: int
+    reveal_type(a / x)  # revealed: float
+    reveal_type(a % x)  # revealed: int
+
+def both_are_bool(x: bool, y: bool):
+    reveal_type(x + y)  # revealed: int
+    reveal_type(x - y)  # revealed: int
+    reveal_type(x * y)  # revealed: int
+    reveal_type(x // y)  # revealed: int
+    reveal_type(x / y)  # revealed: float
+    reveal_type(x % y)  # revealed: int
+```

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

@@ -0,0 +1,17 @@
+# Binary operations on classes
+
+## Union of two classes
+
+Unioning two classes via the `|` operator is only available in Python 3.10 and later.
+
+```toml
+[environment]
+python-version = "3.10"
+```
+
+```py
+class A: ...
+class B: ...
+
+reveal_type(A | B)  # revealed: UnionType
+```

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

@@ -0,0 +1,217 @@
+# Custom binary operations
+
+## Class instances
+
+```py
+class Yes:
+    def __add__(self, other) -> Literal["+"]:
+        return "+"
+
+    def __sub__(self, other) -> Literal["-"]:
+        return "-"
+
+    def __mul__(self, other) -> Literal["*"]:
+        return "*"
+
+    def __matmul__(self, other) -> Literal["@"]:
+        return "@"
+
+    def __truediv__(self, other) -> Literal["/"]:
+        return "/"
+
+    def __mod__(self, other) -> Literal["%"]:
+        return "%"
+
+    def __pow__(self, other) -> Literal["**"]:
+        return "**"
+
+    def __lshift__(self, other) -> Literal["<<"]:
+        return "<<"
+
+    def __rshift__(self, other) -> Literal[">>"]:
+        return ">>"
+
+    def __or__(self, other) -> Literal["|"]:
+        return "|"
+
+    def __xor__(self, other) -> Literal["^"]:
+        return "^"
+
+    def __and__(self, other) -> Literal["&"]:
+        return "&"
+
+    def __floordiv__(self, other) -> Literal["//"]:
+        return "//"
+
+class Sub(Yes): ...
+class No: ...
+
+# Yes implements all of the dunder methods.
+reveal_type(Yes() + Yes())  # revealed: Literal["+"]
+reveal_type(Yes() - Yes())  # revealed: Literal["-"]
+reveal_type(Yes() * Yes())  # revealed: Literal["*"]
+reveal_type(Yes() @ Yes())  # revealed: Literal["@"]
+reveal_type(Yes() / Yes())  # revealed: Literal["/"]
+reveal_type(Yes() % Yes())  # revealed: Literal["%"]
+reveal_type(Yes() ** Yes())  # revealed: Literal["**"]
+reveal_type(Yes() << Yes())  # revealed: Literal["<<"]
+reveal_type(Yes() >> Yes())  # revealed: Literal[">>"]
+reveal_type(Yes() | Yes())  # revealed: Literal["|"]
+reveal_type(Yes() ^ Yes())  # revealed: Literal["^"]
+reveal_type(Yes() & Yes())  # revealed: Literal["&"]
+reveal_type(Yes() // Yes())  # revealed: Literal["//"]
+
+# Sub inherits Yes's implementation of the dunder methods.
+reveal_type(Sub() + Sub())  # revealed: Literal["+"]
+reveal_type(Sub() - Sub())  # revealed: Literal["-"]
+reveal_type(Sub() * Sub())  # revealed: Literal["*"]
+reveal_type(Sub() @ Sub())  # revealed: Literal["@"]
+reveal_type(Sub() / Sub())  # revealed: Literal["/"]
+reveal_type(Sub() % Sub())  # revealed: Literal["%"]
+reveal_type(Sub() ** Sub())  # revealed: Literal["**"]
+reveal_type(Sub() << Sub())  # revealed: Literal["<<"]
+reveal_type(Sub() >> Sub())  # revealed: Literal[">>"]
+reveal_type(Sub() | Sub())  # revealed: Literal["|"]
+reveal_type(Sub() ^ Sub())  # revealed: Literal["^"]
+reveal_type(Sub() & Sub())  # revealed: Literal["&"]
+reveal_type(Sub() // Sub())  # revealed: Literal["//"]
+
+# No does not implement any of the dunder methods.
+# error: [unsupported-operator] "Operator `+` is unsupported between objects of type `No` and `No`"
+reveal_type(No() + No())  # revealed: Unknown
+# error: [unsupported-operator] "Operator `-` is unsupported between objects of type `No` and `No`"
+reveal_type(No() - No())  # revealed: Unknown
+# error: [unsupported-operator] "Operator `*` is unsupported between objects of type `No` and `No`"
+reveal_type(No() * No())  # revealed: Unknown
+# error: [unsupported-operator] "Operator `@` is unsupported between objects of type `No` and `No`"
+reveal_type(No() @ No())  # revealed: Unknown
+# error: [unsupported-operator] "Operator `/` is unsupported between objects of type `No` and `No`"
+reveal_type(No() / No())  # revealed: Unknown
+# error: [unsupported-operator] "Operator `%` is unsupported between objects of type `No` and `No`"
+reveal_type(No() % No())  # revealed: Unknown
+# error: [unsupported-operator] "Operator `**` is unsupported between objects of type `No` and `No`"
+reveal_type(No() ** No())  # revealed: Unknown
+# error: [unsupported-operator] "Operator `<<` is unsupported between objects of type `No` and `No`"
+reveal_type(No() << No())  # revealed: Unknown
+# error: [unsupported-operator] "Operator `>>` is unsupported between objects of type `No` and `No`"
+reveal_type(No() >> No())  # revealed: Unknown
+# error: [unsupported-operator] "Operator `|` is unsupported between objects of type `No` and `No`"
+reveal_type(No() | No())  # revealed: Unknown
+# error: [unsupported-operator] "Operator `^` is unsupported between objects of type `No` and `No`"
+reveal_type(No() ^ No())  # revealed: Unknown
+# error: [unsupported-operator] "Operator `&` is unsupported between objects of type `No` and `No`"
+reveal_type(No() & No())  # revealed: Unknown
+# error: [unsupported-operator] "Operator `//` is unsupported between objects of type `No` and `No`"
+reveal_type(No() // No())  # revealed: Unknown
+
+# Yes does not implement any of the reflected dunder methods.
+# error: [unsupported-operator] "Operator `+` is unsupported between objects of type `No` and `Yes`"
+reveal_type(No() + Yes())  # revealed: Unknown
+# error: [unsupported-operator] "Operator `-` is unsupported between objects of type `No` and `Yes`"
+reveal_type(No() - Yes())  # revealed: Unknown
+# error: [unsupported-operator] "Operator `*` is unsupported between objects of type `No` and `Yes`"
+reveal_type(No() * Yes())  # revealed: Unknown
+# error: [unsupported-operator] "Operator `@` is unsupported between objects of type `No` and `Yes`"
+reveal_type(No() @ Yes())  # revealed: Unknown
+# error: [unsupported-operator] "Operator `/` is unsupported between objects of type `No` and `Yes`"
+reveal_type(No() / Yes())  # revealed: Unknown
+# error: [unsupported-operator] "Operator `%` is unsupported between objects of type `No` and `Yes`"
+reveal_type(No() % Yes())  # revealed: Unknown
+# error: [unsupported-operator] "Operator `**` is unsupported between objects of type `No` and `Yes`"
+reveal_type(No() ** Yes())  # revealed: Unknown
+# error: [unsupported-operator] "Operator `<<` is unsupported between objects of type `No` and `Yes`"
+reveal_type(No() << Yes())  # revealed: Unknown
+# error: [unsupported-operator] "Operator `>>` is unsupported between objects of type `No` and `Yes`"
+reveal_type(No() >> Yes())  # revealed: Unknown
+# error: [unsupported-operator] "Operator `|` is unsupported between objects of type `No` and `Yes`"
+reveal_type(No() | Yes())  # revealed: Unknown
+# error: [unsupported-operator] "Operator `^` is unsupported between objects of type `No` and `Yes`"
+reveal_type(No() ^ Yes())  # revealed: Unknown
+# error: [unsupported-operator] "Operator `&` is unsupported between objects of type `No` and `Yes`"
+reveal_type(No() & Yes())  # revealed: Unknown
+# error: [unsupported-operator] "Operator `//` is unsupported between objects of type `No` and `Yes`"
+reveal_type(No() // Yes())  # revealed: Unknown
+```
+
+## Classes
+
+Dunder methods defined in a class are available to instances of that class, but not to the class
+itself. (For these operators to work on the class itself, they would have to be defined on the
+class's type, i.e. `type`.)
+
+```py
+class Yes:
+    def __add__(self, other) -> Literal["+"]:
+        return "+"
+
+class Sub(Yes): ...
+class No: ...
+
+# error: [unsupported-operator] "Operator `+` is unsupported between objects of type `Literal[Yes]` and `Literal[Yes]`"
+reveal_type(Yes + Yes)  # revealed: Unknown
+# error: [unsupported-operator] "Operator `+` is unsupported between objects of type `Literal[Sub]` and `Literal[Sub]`"
+reveal_type(Sub + Sub)  # revealed: Unknown
+# error: [unsupported-operator] "Operator `+` is unsupported between objects of type `Literal[No]` and `Literal[No]`"
+reveal_type(No + No)  # revealed: Unknown
+```
+
+## Function literals
+
+```py
+def f():
+    pass
+
+# error: [unsupported-operator] "Operator `+` is unsupported between objects of type `Literal[f]` and `Literal[f]`"
+reveal_type(f + f)  # revealed: Unknown
+# error: [unsupported-operator] "Operator `-` is unsupported between objects of type `Literal[f]` and `Literal[f]`"
+reveal_type(f - f)  # revealed: Unknown
+# error: [unsupported-operator] "Operator `*` is unsupported between objects of type `Literal[f]` and `Literal[f]`"
+reveal_type(f * f)  # revealed: Unknown
+# error: [unsupported-operator] "Operator `@` is unsupported between objects of type `Literal[f]` and `Literal[f]`"
+reveal_type(f @ f)  # revealed: Unknown
+# error: [unsupported-operator] "Operator `/` is unsupported between objects of type `Literal[f]` and `Literal[f]`"
+reveal_type(f / f)  # revealed: Unknown
+# error: [unsupported-operator] "Operator `%` is unsupported between objects of type `Literal[f]` and `Literal[f]`"
+reveal_type(f % f)  # revealed: Unknown
+# error: [unsupported-operator] "Operator `**` is unsupported between objects of type `Literal[f]` and `Literal[f]`"
+reveal_type(f**f)  # revealed: Unknown
+# error: [unsupported-operator] "Operator `<<` is unsupported between objects of type `Literal[f]` and `Literal[f]`"
+reveal_type(f << f)  # revealed: Unknown
+# error: [unsupported-operator] "Operator `>>` is unsupported between objects of type `Literal[f]` and `Literal[f]`"
+reveal_type(f >> f)  # revealed: Unknown
+# error: [unsupported-operator] "Operator `|` is unsupported between objects of type `Literal[f]` and `Literal[f]`"
+reveal_type(f | f)  # revealed: Unknown
+# error: [unsupported-operator] "Operator `^` is unsupported between objects of type `Literal[f]` and `Literal[f]`"
+reveal_type(f ^ f)  # revealed: Unknown
+# error: [unsupported-operator] "Operator `&` is unsupported between objects of type `Literal[f]` and `Literal[f]`"
+reveal_type(f & f)  # revealed: Unknown
+# error: [unsupported-operator] "Operator `//` is unsupported between objects of type `Literal[f]` and `Literal[f]`"
+reveal_type(f // f)  # revealed: Unknown
+```
+
+## Subclass
+
+```py
+class Yes:
+    def __add__(self, other) -> Literal["+"]:
+        return "+"
+
+class Sub(Yes): ...
+class No: ...
+
+def yes() -> type[Yes]:
+    return Yes
+
+def sub() -> type[Sub]:
+    return Sub
+
+def no() -> type[No]:
+    return No
+
+# error: [unsupported-operator] "Operator `+` is unsupported between objects of type `type[Yes]` and `type[Yes]`"
+reveal_type(yes() + yes())  # revealed: Unknown
+# error: [unsupported-operator] "Operator `+` is unsupported between objects of type `type[Sub]` and `type[Sub]`"
+reveal_type(sub() + sub())  # revealed: Unknown
+# error: [unsupported-operator] "Operator `+` is unsupported between objects of type `type[No]` and `type[No]`"
+reveal_type(no() + no())  # revealed: Unknown
+```

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

@@ -9,6 +9,34 @@ reveal_type(3 * -1)  # revealed: Literal[-3]
 reveal_type(-3 // 3)  # revealed: Literal[-1]
 reveal_type(-3 / 3)  # revealed: float
 reveal_type(5 % 3)  # revealed: Literal[2]
+
+# TODO: We don't currently verify that the actual parameter to int.__add__ matches the declared
+# formal parameter type.
+reveal_type(2 + "f")  # revealed: int
+
+def lhs(x: int):
+    reveal_type(x + 1)  # revealed: int
+    reveal_type(x - 4)  # revealed: int
+    reveal_type(x * -1)  # revealed: int
+    reveal_type(x // 3)  # revealed: int
+    reveal_type(x / 3)  # revealed: float
+    reveal_type(x % 3)  # revealed: int
+
+def rhs(x: int):
+    reveal_type(2 + x)  # revealed: int
+    reveal_type(3 - x)  # revealed: int
+    reveal_type(3 * x)  # revealed: int
+    reveal_type(-3 // x)  # revealed: int
+    reveal_type(-3 / x)  # revealed: float
+    reveal_type(5 % x)  # revealed: int
+
+def both(x: int):
+    reveal_type(x + x)  # revealed: int
+    reveal_type(x - x)  # revealed: int
+    reveal_type(x * x)  # revealed: int
+    reveal_type(x // x)  # revealed: int
+    reveal_type(x / x)  # revealed: float
+    reveal_type(x % x)  # revealed: int
 ```
 
 ## Power
@@ -21,6 +49,11 @@ largest_u32 = 4_294_967_295
 reveal_type(2**2)  # revealed: Literal[4]
 reveal_type(1 ** (largest_u32 + 1))  # revealed: int
 reveal_type(2**largest_u32)  # revealed: int
+
+def variable(x: int):
+    reveal_type(x**2)  # revealed: @Todo(return type)
+    reveal_type(2**x)  # revealed: @Todo(return type)
+    reveal_type(x**x)  # revealed: @Todo(return type)
 ```
 
 ## Division by Zero

crates/red_knot_python_semantic/resources/mdtest/slots.md

@@ -167,7 +167,7 @@ class A:
     __slots__ = ()
     __slots__ += ("a", "b")
 
-reveal_type(A.__slots__)  # revealed: @Todo(Support for more binary expressions)
+reveal_type(A.__slots__)  # revealed: @Todo(return type)
 
 class B:
     __slots__ = ("c", "d")

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

@@ -34,6 +34,10 @@ reveal_type(~No())  # revealed: Unknown
 
 ## Classes
 
+Dunder methods defined in a class are available to instances of that class, but not to the class
+itself. (For these operators to work on the class itself, they would have to be defined on the
+class's type, i.e. `type`.)
+
 ```py
 class Yes:
     def __pos__(self) -> bool: