First batch of review comments (minus call outcome feedback)

Author: MichaReiser

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

@@ -40,7 +40,7 @@ class C:
         return 42
 
 x = C()
-# error: [unsupported-operator]
+# error: [unsupported-operator] "Operator `-=` is unsupported between objects of type `C` and `Literal[1]`"
 x -= 1
 
 reveal_type(x)  # revealed: int

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

@@ -260,8 +260,8 @@ class B:
     __add__ = A()
 
 # TODO: this could be `int` if we declare `B.__add__` using a `Callable` type
-# TODO: This should not be an error but we currently fail to bind `self` in `A.__call__` as `B`
-#       and instead bind it to `A` which makes the `__add__` call fail.
+# TODO: Should not be an error: `A` instance is not a method descriptor, don't prepend `self` arg.
+#   Revealed type should be `Unknown | int`.
 # error: [unsupported-operator] "Operator `+` is unsupported between objects of type `B` and `B`"
 reveal_type(B() + B())  # revealed: Unknown
 ```

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

@@ -10,9 +10,9 @@ 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.
-# TODO: Should this emit an error?
+# TODO: This should emit an unsupported-operator error but we don't currently 
+#  verify that the actual parameter to `int.__add__` matches the declared
+#  formal parameter type.
 reveal_type(2 + "f")  # revealed: Unknown
 
 def lhs(x: int):

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

@@ -99,3 +99,27 @@ c = C()
 # error: 13 [invalid-argument-type] "Object of type `C` cannot be assigned to parameter 1 (`self`) of function `__call__`; expected type `int`"
 reveal_type(c())  # revealed: int
 ```
+
+## Union over callables
+
+### Possibly unbound `__call__`
+
+```py
+def outer(cond1: bool):
+	class Test:
+		if cond1:
+			def __call__(self): ...
+	
+	class Other:
+		def __call__(self): ...
+	
+	def inner(cond2: bool): 
+		if cond2:
+			a = Test()
+		else:
+			a = Other()
+	
+        # TODO: Improve the error message to a) be more specific what `__call__` is and b) mention that it is possibly unbound.
+        # error: [call-non-callable] "Object of type `Test | Other` is not callable (due to union element `Literal[__call__]`)"
+		a()
+```

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

@@ -81,8 +81,8 @@ def _(flag: bool):
 Calling a union where the arguments don't match the signature of all variants.
 
 ```py
-def f1(a: int): ...
-def f2(a: str): ...
+def f1(a: int) -> int: ...
+def f2(a: str) -> str: ...
 def _(flag: bool):
     if flag:
         f = f1
@@ -91,20 +91,20 @@ def _(flag: bool):
 
     # error: [call-non-callable] "Object of type `Literal[f1, f2]` is not callable (due to union element `Literal[f2]`)"
     x = f(3)
-    reveal_type(x)  # revealed: Unknown
+    reveal_type(x)  # revealed: int | str
 ```
 
-## Any non callable variant
+## Any non-callable variant
 
 ```py
 def f1(a: int): ...
 def _(flag: bool):
     if flag:
         f = f1
     else:
-        f = "str"
+        f = "This is a string literal"
 
-    # error: [call-non-callable] "Object of type `Literal[f1] | Literal["str"]` is not callable (due to union element `Literal["str"]`)"
+    # error: [call-non-callable] "Object of type `Literal[f1] | Literal["This is a string literal"]` is not callable (due to union element `Literal["This is a string literal"]`)"
     x = f(3)
     reveal_type(x)  # revealed: Unknown
 ```

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

@@ -8,18 +8,15 @@ types, we can infer that the result for the intersection type is also true/false
 ```py
 from typing import Literal
 
-class Base: ...
+class Base:
+    def __gt__(self, other) -> bool:
+        return False
 
 class Child1(Base):
     def __eq__(self, other) -> Literal[True]:
         return True
 
-    def __gt__(self, other) -> bool:
-        return False
-
-class Child2(Base):
-    def __gt__(self, other) -> bool:
-        return False
+class Child2(Base): ...
 
 def _(x: Base):
     c1 = Child1()

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

@@ -23,7 +23,7 @@ from __future__ import annotations
 
 class A:
     def __lt__(self, other) -> A: ...
-    def __gt__(self, other) -> A: ...
+    def __gt__(self, other) -> bool: ...
 
 class B:
     def __lt__(self, other) -> B: ...
@@ -35,7 +35,7 @@ x = A() < B() < C()
 reveal_type(x)  # revealed: A & ~AlwaysTruthy | B
 
 y = 0 < 1 < A() < 3
-reveal_type(y)  # revealed: A
+reveal_type(y)  # revealed: Literal[False] | A
 
 z = 10 < 0 < A() < B() < C()
 reveal_type(z)  # revealed: Literal[False]

crates/red_knot_python_semantic/resources/mdtest/loops/for.md

@@ -245,6 +245,7 @@ class Test2:
         return 42
 
 def _(flag: bool):
+    # TODO: Improve error message to state which union variant isn't iterable (https://github.com/astral-sh/ruff/issues/13989)
     # error: "Object of type `Test | Test2` is not iterable"
     for x in Test() if flag else Test2():
         reveal_type(x)  # revealed: int

crates/red_knot_python_semantic/resources/mdtest/with/sync.md

@@ -80,7 +80,7 @@ class Manager:
 
     def __exit__(self, exc_tpe, exc_value, traceback): ...
 
-# error: [invalid-context-manager] "Object of type `Manager` cannot be used with `with` because the method `__enter__` of type `int` is not callable"
+# error: [invalid-context-manager] "Object of type `Manager` cannot be used with `with` because it does not correctly implement `__enter__`"
 with Manager():
     ...
 ```
@@ -95,7 +95,7 @@ class Manager:
 
     __exit__: int = 32
 
-# error: [invalid-context-manager] "Object of type `Manager` cannot be used with `with` because the method `__exit__` of type `int` is not callable"
+# error: [invalid-context-manager] "Object of type `Manager` cannot be used with `with` because it does not correctly implement `__exit__`"
 with Manager():
     ...
 ```
@@ -146,8 +146,7 @@ class Manager:
 
 context_expr = Manager()
 
-# error: [invalid-context-manager] "Object of type `Manager` cannot be used with `with` because the method `__enter__` of type `Literal[__enter__]` is not callable"
+# error: [invalid-context-manager] "Object of type `Manager` cannot be used with `with` because it does not correctly implement `__enter__`"
 with context_expr as f:
-    # TODO: Should this be Unknown?
     reveal_type(f)  # revealed: str
 ```

crates/red_knot_python_semantic/src/types.rs

@@ -1658,6 +1658,8 @@ impl<'db> Type<'db> {
                             .map(|arg| arg.bool(db).into_type(db))
                             .unwrap_or(Type::BooleanLiteral(false)),
 
+                        // TODO: Don't ignore the second and third arguments to `str`
+                        //   https://github.com/astral-sh/ruff/pull/16161#discussion_r1958425568
                         Some(KnownClass::Str) => arguments
                             .first_argument()
                             .map(|arg| arg.str(db))
@@ -1701,7 +1703,7 @@ impl<'db> Type<'db> {
             Type::Dynamic(_) => Ok(CallOutcome::Single(CallBinding::from_return_type(self))),
 
             Type::Union(union) => {
-                CallOutcome::try_call(db, union, |element| element.call(db, arguments))
+                CallOutcome::try_call_union(db, union, |element| element.call(db, arguments))
             }
 
             Type::Intersection(_) => Ok(CallOutcome::Single(CallBinding::from_return_type(
@@ -1740,7 +1742,7 @@ impl<'db> Type<'db> {
                 self.call(db, arguments)
             }
 
-            Type::Union(union) => CallOutcome::try_call(db, union, |element| {
+            Type::Union(union) => CallOutcome::try_call_union(db, union, |element| {
                 element.call_bound(db, receiver_ty, arguments)
             }),
 
@@ -1826,7 +1828,8 @@ impl<'db> Type<'db> {
                     },
                 };
             }
-            // If the attribute exists but can't be called, return not iterable over falling back to `__get__item`.
+            // If `__iter__` exists but can't be called or doesn't have the expected signature,
+            // return not iterable over falling back to `__getitem__`.
             Err(CallDunderError::Call(_)) => {
                 return IterationOutcome::NotIterable {
                     not_iterable_ty: self,
@@ -3669,7 +3672,7 @@ impl<'db> Class<'db> {
 
                 Err(CallError::NotCallableVariants {
                     called_ty,
-                    not_callable,
+                    call_errors: not_callable,
                     callable,
                 }) => {
                     let mut partly_not_callable = false;