Merge branch 'main' into alex/star-imports-redux

Author: AlexWaygood

CHANGELOG.md

@@ -1421,11 +1421,11 @@ The following rules have been stabilized and are no longer in preview:
 
 The following behaviors have been stabilized:
 
-- [`cancel-scope-no-checkpoint`](https://docs.astral.sh/ruff/rules/cancel-scope-no-checkpoint/) (`ASYNC100`): Support `asyncio` and `anyio` context mangers.
-- [`async-function-with-timeout`](https://docs.astral.sh/ruff/rules/async-function-with-timeout/) (`ASYNC109`): Support `asyncio` and `anyio` context mangers.
-- [`async-busy-wait`](https://docs.astral.sh/ruff/rules/async-busy-wait/) (`ASYNC110`): Support `asyncio` and `anyio` context mangers.
-- [`async-zero-sleep`](https://docs.astral.sh/ruff/rules/async-zero-sleep/) (`ASYNC115`): Support `anyio` context mangers.
-- [`long-sleep-not-forever`](https://docs.astral.sh/ruff/rules/long-sleep-not-forever/) (`ASYNC116`): Support `anyio` context mangers.
+- [`cancel-scope-no-checkpoint`](https://docs.astral.sh/ruff/rules/cancel-scope-no-checkpoint/) (`ASYNC100`): Support `asyncio` and `anyio` context managers.
+- [`async-function-with-timeout`](https://docs.astral.sh/ruff/rules/async-function-with-timeout/) (`ASYNC109`): Support `asyncio` and `anyio` context managers.
+- [`async-busy-wait`](https://docs.astral.sh/ruff/rules/async-busy-wait/) (`ASYNC110`): Support `asyncio` and `anyio` context managers.
+- [`async-zero-sleep`](https://docs.astral.sh/ruff/rules/async-zero-sleep/) (`ASYNC115`): Support `anyio` context managers.
+- [`long-sleep-not-forever`](https://docs.astral.sh/ruff/rules/long-sleep-not-forever/) (`ASYNC116`): Support `anyio` context managers.
 
 The following fixes have been stabilized:
 

crates/red_knot_python_semantic/resources/mdtest/annotations/callable.md

@@ -152,6 +152,21 @@ def _(c: Callable[[int, str], int]):
     reveal_type(c)  # revealed: (int, str, /) -> int
 ```
 
+## Union
+
+```py
+from typing import Callable, Union
+
+def _(
+    c: Callable[[Union[int, str]], int] | None,
+    d: None | Callable[[Union[int, str]], int],
+    e: None | Callable[[Union[int, str]], int] | int,
+):
+    reveal_type(c)  # revealed: ((int | str, /) -> int) | None
+    reveal_type(d)  # revealed: None | ((int | str, /) -> int)
+    reveal_type(e)  # revealed: None | ((int | str, /) -> int) | int
+```
+
 ## Nested
 
 A nested `Callable` as one of the parameter types:

crates/red_knot_python_semantic/resources/mdtest/annotations/unsupported_special_forms.md

@@ -29,8 +29,6 @@ def i(callback: Callable[Concatenate[int, P], R_co], *args: P.args, **kwargs: P.
     # TODO: should understand the annotation
     reveal_type(kwargs)  # revealed: dict
 
-    # TODO: not an error; remove once `call` is implemented for `Callable`
-    # error: [call-non-callable]
     return callback(42, *args, **kwargs)
 
 class Foo:

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

@@ -0,0 +1,43 @@
+# `typing.Callable`
+
+```py
+from typing import Callable
+
+def _(c: Callable[[], int]):
+    reveal_type(c())  # revealed: int
+
+def _(c: Callable[[int, str], int]):
+    reveal_type(c(1, "a"))  # revealed: int
+
+    # error: [invalid-argument-type] "Object of type `Literal["a"]` cannot be assigned to parameter 1; expected type `int`"
+    # error: [invalid-argument-type] "Object of type `Literal[1]` cannot be assigned to parameter 2; expected type `str`"
+    reveal_type(c("a", 1))  # revealed: int
+```
+
+The `Callable` annotation can only be used to describe positional-only parameters.
+
+```py
+def _(c: Callable[[int, str], None]):
+    # error: [unknown-argument] "Argument `a` does not match any known parameter"
+    # error: [unknown-argument] "Argument `b` does not match any known parameter"
+    # error: [missing-argument] "No arguments provided for required parameters 1, 2"
+    reveal_type(c(a=1, b="b"))  # revealed: None
+```
+
+If the annotation uses a gradual form (`...`) for the parameter list, then it can accept any kind of
+parameter with any type.
+
+```py
+def _(c: Callable[..., int]):
+    reveal_type(c())  # revealed: int
+    reveal_type(c(1))  # revealed: int
+    reveal_type(c(1, "str", False, a=[1, 2], b=(3, 4)))  # revealed: int
+```
+
+An invalid `Callable` form can accept any parameters and will return `Unknown`.
+
+```py
+# error: [invalid-type-form]
+def _(c: Callable[42, str]):
+    reveal_type(c())  # revealed: Unknown
+```

crates/red_knot_python_semantic/resources/mdtest/exception/except_star.md

@@ -24,7 +24,7 @@ try:
     help()
 except* OSError as e:
     # TODO: more precise would be `ExceptionGroup[OSError]` --Alex
-    # (needs homogenous tuples + generics)
+    # (needs homogeneous tuples + generics)
     reveal_type(e)  # revealed: BaseExceptionGroup
 ```
 
@@ -35,7 +35,7 @@ try:
     help()
 except* (TypeError, AttributeError) as e:
     # TODO: more precise would be `ExceptionGroup[TypeError | AttributeError]` --Alex
-    # (needs homogenous tuples + generics)
+    # (needs homogeneous tuples + generics)
     reveal_type(e)  # revealed: BaseExceptionGroup
 ```
 

crates/red_knot_python_semantic/resources/mdtest/expression/lambda.md

@@ -76,7 +76,7 @@ Using a parameter with default value:
 lambda x=1: reveal_type(x)  # revealed: Unknown | Literal[1]
 ```
 
-Using a variadic paramter:
+Using a variadic parameter:
 
 ```py
 # TODO: should be `tuple[Unknown, ...]` (needs generics)
@@ -98,3 +98,22 @@ expression.
 ```py
 reveal_type(lambda a=lambda x, y: 0: 2)  # revealed: (a=(x, y) -> Unknown) -> Unknown
 ```
+
+## Assignment
+
+This does not enumerate all combinations of parameter kinds as that should be covered by the
+[subtype tests for callable types](./../type_properties/is_subtype_of.md#callable).
+
+```py
+from typing import Callable
+
+a1: Callable[[], None] = lambda: None
+a2: Callable[[int], None] = lambda x: None
+a3: Callable[[int, int], None] = lambda x, y, z=1: None
+a4: Callable[[int, int], None] = lambda *args: None
+
+# error: [invalid-assignment]
+a5: Callable[[], None] = lambda x: None
+# error: [invalid-assignment]
+a6: Callable[[int], None] = lambda: None
+```

crates/red_knot_python_semantic/resources/mdtest/type_properties/is_assignable_to.md

@@ -393,4 +393,87 @@ static_assert(is_assignable_to(Never, type[str]))
 static_assert(is_assignable_to(Never, type[Any]))
 ```
 
+## Callable
+
+The examples provided below are only a subset of the possible cases and include the ones with
+gradual types. The cases with fully static types and using different combinations of parameter kinds
+are covered in the [subtyping tests](./is_subtype_of.md#callable).
+
+### Return type
+
+```py
+from knot_extensions import CallableTypeFromFunction, Unknown, static_assert, is_assignable_to
+from typing import Any, Callable
+
+static_assert(is_assignable_to(Callable[[], Any], Callable[[], int]))
+static_assert(is_assignable_to(Callable[[], int], Callable[[], Any]))
+
+static_assert(is_assignable_to(Callable[[], int], Callable[[], float]))
+static_assert(not is_assignable_to(Callable[[], float], Callable[[], int]))
+```
+
+The return types should be checked even if the parameter types uses gradual form (`...`).
+
+```py
+static_assert(is_assignable_to(Callable[..., int], Callable[..., float]))
+static_assert(not is_assignable_to(Callable[..., float], Callable[..., int]))
+```
+
+And, if there is no return type, the return type is `Unknown`.
+
+```py
+static_assert(is_assignable_to(Callable[[], Unknown], Callable[[], int]))
+static_assert(is_assignable_to(Callable[[], int], Callable[[], Unknown]))
+```
+
+### Parameter types
+
+A `Callable` which uses the gradual form (`...`) for the parameter types is consistent with any
+input signature.
+
+```py
+from knot_extensions import CallableTypeFromFunction, static_assert, is_assignable_to
+from typing import Any, Callable
+
+static_assert(is_assignable_to(Callable[[], None], Callable[..., None]))
+static_assert(is_assignable_to(Callable[..., None], Callable[..., None]))
+static_assert(is_assignable_to(Callable[[int, float, str], None], Callable[..., None]))
+```
+
+Even if it includes any other parameter kinds.
+
+```py
+def positional_only(a: int, b: int, /) -> None: ...
+def positional_or_keyword(a: int, b: int) -> None: ...
+def variadic(*args: int) -> None: ...
+def keyword_only(*, a: int, b: int) -> None: ...
+def keyword_variadic(**kwargs: int) -> None: ...
+def mixed(a: int, /, b: int, *args: int, c: int, **kwargs: int) -> None: ...
+
+static_assert(is_assignable_to(CallableTypeFromFunction[positional_only], Callable[..., None]))
+static_assert(is_assignable_to(CallableTypeFromFunction[positional_or_keyword], Callable[..., None]))
+static_assert(is_assignable_to(CallableTypeFromFunction[variadic], Callable[..., None]))
+static_assert(is_assignable_to(CallableTypeFromFunction[keyword_only], Callable[..., None]))
+static_assert(is_assignable_to(CallableTypeFromFunction[keyword_variadic], Callable[..., None]))
+static_assert(is_assignable_to(CallableTypeFromFunction[mixed], Callable[..., None]))
+```
+
+And, even if the parameters are unannotated.
+
+```py
+def positional_only(a, b, /) -> None: ...
+def positional_or_keyword(a, b) -> None: ...
+def variadic(*args) -> None: ...
+def keyword_only(*, a, b) -> None: ...
+def keyword_variadic(**kwargs) -> None: ...
+def mixed(a, /, b, *args, c, **kwargs) -> None: ...
+
+static_assert(is_assignable_to(CallableTypeFromFunction[positional_only], Callable[..., None]))
+static_assert(is_assignable_to(CallableTypeFromFunction[positional_or_keyword], Callable[..., None]))
+static_assert(is_assignable_to(CallableTypeFromFunction[variadic], Callable[..., None]))
+static_assert(is_assignable_to(CallableTypeFromFunction[keyword_only], Callable[..., None]))
+static_assert(is_assignable_to(CallableTypeFromFunction[keyword_variadic], Callable[..., None]))
+static_assert(is_assignable_to(CallableTypeFromFunction[mixed], Callable[..., None]))
+```
+
 [typing documentation]: https://typing.readthedocs.io/en/latest/spec/concepts.html#the-assignable-to-or-consistent-subtyping-relation

crates/red_knot_python_semantic/src/ast_node_ref.rs

@@ -17,7 +17,7 @@ use ruff_db::parsed::ParsedModule;
 /// ## Usage in salsa tracked structs
 /// It's important that [`AstNodeRef`] fields in salsa tracked structs are tracked fields
 /// (attributed with `#[tracked`]). It prevents that the tracked struct gets a new ID
-/// everytime the AST changes, which in turn, invalidates the result of any query
+/// every time the AST changes, which in turn, invalidates the result of any query
 /// that takes said tracked struct as a query argument or returns the tracked struct as part of its result.
 ///
 /// For example, marking the [`AstNodeRef`] as tracked on `Expression`

crates/red_knot_python_semantic/src/module_resolver/resolver.rs

@@ -224,6 +224,9 @@ impl SearchPaths {
 
         let site_packages_paths = match python_path {
             PythonPath::SysPrefix(sys_prefix, origin) => {
+                tracing::debug!(
+                    "Discovering site-packages paths from sys-prefix `{sys_prefix}` ({origin}')"
+                );
                 // TODO: We may want to warn here if the venv's python version is older
                 //  than the one resolved in the program settings because it indicates
                 //  that the `target-version` is incorrectly configured or that the

crates/red_knot_python_semantic/src/semantic_index/builder.rs

@@ -961,7 +961,7 @@ where
 
                 self.with_type_params(
                     NodeWithScopeRef::TypeAliasTypeParameters(type_alias),
-                    type_alias.type_params.as_ref(),
+                    type_alias.type_params.as_deref(),
                     |builder| {
                         builder.push_scope(NodeWithScopeRef::TypeAlias(type_alias));
                         builder.visit_expr(&type_alias.value);