[red-knot] Super-basic generic inference at call sites

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

@@ -410,29 +410,19 @@ def does_nothing[T](f: T) -> T:
 
 class C:
     @classmethod
-    # TODO: no error should be emitted here (needs support for generics)
-    # error: [invalid-argument-type]
     @does_nothing
     def f1(cls: type[C], x: int) -> str:
         return "a"
-    # TODO: no error should be emitted here (needs support for generics)
-    # error: [invalid-argument-type]
+
     @does_nothing
     @classmethod
     def f2(cls: type[C], x: int) -> str:
         return "a"
 
-# TODO: All of these should be `str` (and not emit an error), once we support generics
-
-# error: [call-non-callable]
-reveal_type(C.f1(1))  # revealed: Unknown
-# error: [call-non-callable]
-reveal_type(C().f1(1))  # revealed: Unknown
-
-# error: [call-non-callable]
-reveal_type(C.f2(1))  # revealed: Unknown
-# error: [call-non-callable]
-reveal_type(C().f2(1))  # revealed: Unknown
+reveal_type(C.f1(1))  # revealed: str
+reveal_type(C().f1(1))  # revealed: str
+reveal_type(C.f2(1))  # revealed: str
+reveal_type(C().f2(1))  # revealed: str
 ```
 
 [functions and methods]: https://docs.python.org/3/howto/descriptor.html#functions-and-methods

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

@@ -156,8 +156,7 @@ parameter:
 class E[T]:
     def __init__(self, x: T) -> None: ...
 
-# TODO: revealed: E[int] or E[Literal[1]]
-reveal_type(E(1))  # revealed: E[Unknown]
+reveal_type(E(1))  # revealed: E[Literal[1]]
 ```
 
 The types inferred from a type context and from a constructor parameter must be consistent with each
@@ -200,10 +199,7 @@ class C[T]:
     def cannot_shadow_class_typevar[T](self, t: T): ...
 
 c: C[int] = C[int]()
-# TODO: no error
-# TODO: revealed: str or Literal["string"]
-# error: [invalid-argument-type]
-reveal_type(c.method("string"))  # revealed: U
+reveal_type(c.method("string"))  # revealed: Literal["string"]
 ```
 
 ## Cyclic class definition

crates/red_knot_python_semantic/resources/mdtest/generics/functions.md

@@ -51,25 +51,10 @@ the inferred type to e.g. `int`.
 def f[T](x: T) -> T:
     return x
 
-# TODO: no error
-# TODO: revealed: int or Literal[1]
-# error: [invalid-argument-type]
-reveal_type(f(1))  # revealed: T
-
-# TODO: no error
-# TODO: revealed: float
-# error: [invalid-argument-type]
-reveal_type(f(1.0))  # revealed: T
-
-# TODO: no error
-# TODO: revealed: bool or Literal[true]
-# error: [invalid-argument-type]
-reveal_type(f(True))  # revealed: T
-
-# TODO: no error
-# TODO: revealed: str or Literal["string"]
-# error: [invalid-argument-type]
-reveal_type(f("string"))  # revealed: T
+reveal_type(f(1))  # revealed: Literal[1]
+reveal_type(f(1.0))  # revealed: float
+reveal_type(f(True))  # revealed: Literal[True]
+reveal_type(f("string"))  # revealed: Literal["string"]
 ```
 
 ## Inferring “deep” generic parameter types
@@ -82,7 +67,7 @@ def f[T](x: list[T]) -> T:
     return x[0]
 
 # TODO: revealed: float
-reveal_type(f([1.0, 2.0]))  # revealed: T
+reveal_type(f([1.0, 2.0]))  # revealed: Unknown
 ```
 
 ## Typevar constraints
@@ -162,61 +147,46 @@ parameters simultaneously.
 def two_params[T](x: T, y: T) -> T:
     return x
 
-# TODO: no error
 # TODO: revealed: str
-# error: [invalid-argument-type]
-# error: [invalid-argument-type]
-reveal_type(two_params("a", "b"))  # revealed: T
+reveal_type(two_params("a", "b"))  # revealed: Literal["a", "b"]
 
-# TODO: no error
 # TODO: revealed: str | int
-# error: [invalid-argument-type]
-# error: [invalid-argument-type]
-reveal_type(two_params("a", 1))  # revealed: T
+reveal_type(two_params("a", 1))  # revealed: Literal["a", 1]
 ```
 
-```py
-def param_with_union[T](x: T | int, y: T) -> T:
-    return y
+When one of the parameters is a union, we attempt to find the smallest specialization that satisfies
+all of the constraints.
 
-# TODO: no error
-# TODO: revealed: str
-# error: [invalid-argument-type]
-reveal_type(param_with_union(1, "a"))  # revealed: T
+```py
+# TODO: make this return list[T], so that we can write a correct body
+# error: [invalid-return-type]
+def union_param[T](x: T | None) -> T: ...
 
-# TODO: no error
-# TODO: revealed: str
-# error: [invalid-argument-type]
-# error: [invalid-argument-type]
-reveal_type(param_with_union("a", "a"))  # revealed: T
+reveal_type(union_param("a"))  # revealed: Literal["a"]
+reveal_type(union_param(1))  # revealed: Literal[1]
+reveal_type(union_param(None))  # revealed: Unknown
+```
 
-# TODO: no error
-# TODO: revealed: int
-# error: [invalid-argument-type]
-reveal_type(param_with_union(1, 1))  # revealed: T
+```py
+def union_and_nonunion_params[T](x: T | int, y: T) -> T:
+    return y
 
-# TODO: no error
-# TODO: revealed: str | int
-# error: [invalid-argument-type]
-# error: [invalid-argument-type]
-reveal_type(param_with_union("a", 1))  # revealed: T
+reveal_type(union_and_nonunion_params(1, "a"))  # revealed: Literal["a"]
+reveal_type(union_and_nonunion_params("a", "a"))  # revealed: Literal["a"]
+reveal_type(union_and_nonunion_params(1, 1))  # revealed: Literal[1]
+reveal_type(union_and_nonunion_params(3, 1))  # revealed: Literal[1]
+reveal_type(union_and_nonunion_params("a", 1))  # revealed: Literal["a", 1]
 ```
 
 ```py
 def tuple_param[T, S](x: T | S, y: tuple[T, S]) -> tuple[T, S]:
     return y
 
-# TODO: no error
 # TODO: revealed: tuple[str, int]
-# error: [invalid-argument-type]
-# error: [invalid-argument-type]
-reveal_type(tuple_param("a", ("a", 1)))  # revealed: tuple[T, S]
+reveal_type(tuple_param("a", ("a", 1)))  # revealed: tuple[Literal["a"], Literal[1]]
 
-# TODO: no error
 # TODO: revealed: tuple[str, int]
-# error: [invalid-argument-type]
-# error: [invalid-argument-type]
-reveal_type(tuple_param(1, ("a", 1)))  # revealed: tuple[T, S]
+reveal_type(tuple_param(1, ("a", 1)))  # revealed: tuple[Literal["a"], Literal[1]]
 ```
 
 ## Inferring nested generic function calls
@@ -231,15 +201,9 @@ def f[T](x: T) -> tuple[T, int]:
 def g[T](x: T) -> T | None:
     return x
 
-# TODO: no error
 # TODO: revealed: tuple[str | None, int]
-# error: [invalid-argument-type]
-# error: [invalid-argument-type]
-reveal_type(f(g("a")))  # revealed: tuple[T, int]
+reveal_type(f(g("a")))  # revealed: tuple[Literal["a"] | None, int]
 
-# TODO: no error
 # TODO: revealed: tuple[str, int] | None
-# error: [invalid-argument-type]
-# error: [invalid-argument-type]
-reveal_type(g(f("a")))  # revealed: T | None
+reveal_type(g(f("a")))  # revealed: tuple[Literal["a"], int] | None
 ```

crates/red_knot_python_semantic/resources/mdtest/generics/scoping.md

@@ -59,14 +59,8 @@ to a different type each time.
 def f[T](x: T) -> T:
     return x
 
-# TODO: no error
-# TODO: revealed: int or Literal[1]
-# error: [invalid-argument-type]
-reveal_type(f(1))  # revealed: T
-# TODO: no error
-# TODO: revealed: str or Literal["a"]
-# error: [invalid-argument-type]
-reveal_type(f("a"))  # revealed: T
+reveal_type(f(1))  # revealed: Literal[1]
+reveal_type(f("a"))  # revealed: Literal["a"]
 ```
 
 ## Methods can mention class typevars
@@ -157,10 +151,7 @@ class C[T]:
         return y
 
 c: C[int] = C()
-# TODO: no errors
-# TODO: revealed: str
-# error: [invalid-argument-type]
-reveal_type(c.m(1, "string"))  # revealed: S
+reveal_type(c.m(1, "string"))  # revealed: Literal["string"]
 ```
 
 ## Unbound typevars