Merge branch 'astral-sh:main' into impl-redefined-slots-in-subclass-W…

…0244

Cargo.toml

@@ -118,7 +118,8 @@ rand = { version = "0.8.5" }
 rayon = { version = "1.10.0" }
 regex = { version = "1.10.2" }
 rustc-hash = { version = "2.0.0" }
-salsa = { git = "https://github.com/salsa-rs/salsa.git", rev = "254c749b02cde2fd29852a7463a33e800b771758" }
+# When updating salsa, make sure to also update the revision in `fuzz/Cargo.toml`
+salsa = { git = "https://github.com/salsa-rs/salsa.git", rev = "3c7f1694c9efba751dbeeacfbc93b227586e316a" }
 schemars = { version = "0.8.16" }
 seahash = { version = "4.1.0" }
 serde = { version = "1.0.197", features = ["derive"] }

crates/red_knot/src/main.rs

@@ -279,7 +279,7 @@ impl MainLoop {
         while let Ok(message) = self.receiver.recv() {
             match message {
                 MainLoopMessage::CheckWorkspace => {
-                    let db = db.snapshot();
+                    let db = db.clone();
                     let sender = self.sender.clone();
 
                     // Spawn a new task that checks the workspace. This needs to be done in a separate thread

crates/red_knot_python_semantic/Cargo.toml

@@ -26,6 +26,7 @@ bitflags = { workspace = true }
 camino = { workspace = true }
 compact_str = { workspace = true }
 countme = { workspace = true }
+drop_bomb = { workspace = true }
 indexmap = { workspace = true }
 itertools = { workspace = true }
 ordermap = { workspace = true }
@@ -58,4 +59,3 @@ serde = ["ruff_db/serde", "dep:serde"]
 
 [lints]
 workspace = true
-

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

@@ -3,43 +3,59 @@
 The `typing` module has various aliases to other stdlib classes. These are a legacy feature, but
 still need to be supported by a type checker.
 
-## Currently unsupported
+## Correspondence
 
-Support for most of these symbols is currently a TODO:
+All of the following symbols can be mapped one-to-one with the actual type:
 
 ```py
 import typing
 
 def f(
-    a: typing.List,
-    b: typing.List[int],
-    c: typing.Dict,
-    d: typing.Dict[int, str],
-    e: typing.DefaultDict,
-    f: typing.DefaultDict[str, int],
-    g: typing.Set,
-    h: typing.Set[int],
-    i: typing.FrozenSet,
-    j: typing.FrozenSet[str],
-    k: typing.OrderedDict,
-    l: typing.OrderedDict[int, str],
-    m: typing.Counter,
-    n: typing.Counter[int],
+    list_bare: typing.List,
+    list_parametrized: typing.List[int],
+    dict_bare: typing.Dict,
+    dict_parametrized: typing.Dict[int, str],
+    set_bare: typing.Set,
+    set_parametrized: typing.Set[int],
+    frozen_set_bare: typing.FrozenSet,
+    frozen_set_parametrized: typing.FrozenSet[str],
+    chain_map_bare: typing.ChainMap,
+    chain_map_parametrized: typing.ChainMap[int],
+    counter_bare: typing.Counter,
+    counter_parametrized: typing.Counter[int],
+    default_dict_bare: typing.DefaultDict,
+    default_dict_parametrized: typing.DefaultDict[str, int],
+    deque_bare: typing.Deque,
+    deque_parametrized: typing.Deque[str],
+    ordered_dict_bare: typing.OrderedDict,
+    ordered_dict_parametrized: typing.OrderedDict[int, str],
 ):
-    reveal_type(a)  # revealed: @Todo(Unsupported or invalid type in a type expression)
-    reveal_type(b)  # revealed: @Todo(typing.List alias)
-    reveal_type(c)  # revealed: @Todo(Unsupported or invalid type in a type expression)
-    reveal_type(d)  # revealed: @Todo(typing.Dict alias)
-    reveal_type(e)  # revealed: @Todo(Unsupported or invalid type in a type expression)
-    reveal_type(f)  # revealed: @Todo(typing.DefaultDict[] alias)
-    reveal_type(g)  # revealed: @Todo(Unsupported or invalid type in a type expression)
-    reveal_type(h)  # revealed: @Todo(typing.Set alias)
-    reveal_type(i)  # revealed: @Todo(Unsupported or invalid type in a type expression)
-    reveal_type(j)  # revealed: @Todo(typing.FrozenSet alias)
-    reveal_type(k)  # revealed: @Todo(Unsupported or invalid type in a type expression)
-    reveal_type(l)  # revealed: @Todo(typing.OrderedDict alias)
-    reveal_type(m)  # revealed: @Todo(Unsupported or invalid type in a type expression)
-    reveal_type(n)  # revealed: @Todo(typing.Counter[] alias)
+    reveal_type(list_bare)  # revealed: list
+    reveal_type(list_parametrized)  # revealed: list
+
+    reveal_type(dict_bare)  # revealed: dict
+    reveal_type(dict_parametrized)  # revealed: dict
+
+    reveal_type(set_bare)  # revealed: set
+    reveal_type(set_parametrized)  # revealed: set
+
+    reveal_type(frozen_set_bare)  # revealed: frozenset
+    reveal_type(frozen_set_parametrized)  # revealed: frozenset
+
+    reveal_type(chain_map_bare)  # revealed: ChainMap
+    reveal_type(chain_map_parametrized)  # revealed: ChainMap
+
+    reveal_type(counter_bare)  # revealed: Counter
+    reveal_type(counter_parametrized)  # revealed: Counter
+
+    reveal_type(default_dict_bare)  # revealed: defaultdict
+    reveal_type(default_dict_parametrized)  # revealed: defaultdict
+
+    reveal_type(deque_bare)  # revealed: deque
+    reveal_type(deque_parametrized)  # revealed: deque
+
+    reveal_type(ordered_dict_bare)  # revealed: OrderedDict
+    reveal_type(ordered_dict_parametrized)  # revealed: OrderedDict
 ```
 
 ## Inheritance
@@ -49,35 +65,63 @@ The aliases can be inherited from. Some of these are still partially or wholly T
 ```py
 import typing
 
-class A(typing.Dict): ...
+####################
+### Built-ins
+
+class ListSubclass(typing.List): ...
 
 # TODO: should have `Generic`, should not have `Unknown`
-reveal_type(A.__mro__)  # revealed: tuple[Literal[A], Literal[dict], Unknown, Literal[object]]
+# revealed: tuple[Literal[ListSubclass], Literal[list], Unknown, Literal[object]]
+reveal_type(ListSubclass.__mro__)
 
-class B(typing.List): ...
+class DictSubclass(typing.Dict): ...
 
 # TODO: should have `Generic`, should not have `Unknown`
-reveal_type(B.__mro__)  # revealed: tuple[Literal[B], Literal[list], Unknown, Literal[object]]
+# revealed: tuple[Literal[DictSubclass], Literal[dict], Unknown, Literal[object]]
+reveal_type(DictSubclass.__mro__)
 
-class C(typing.Set): ...
+class SetSubclass(typing.Set): ...
 
 # TODO: should have `Generic`, should not have `Unknown`
-reveal_type(C.__mro__)  # revealed: tuple[Literal[C], Literal[set], Unknown, Literal[object]]
+# revealed: tuple[Literal[SetSubclass], Literal[set], Unknown, Literal[object]]
+reveal_type(SetSubclass.__mro__)
 
-class D(typing.FrozenSet): ...
+class FrozenSetSubclass(typing.FrozenSet): ...
 
 # TODO: should have `Generic`, should not have `Unknown`
-reveal_type(D.__mro__)  # revealed: tuple[Literal[D], Literal[frozenset], Unknown, Literal[object]]
+# revealed: tuple[Literal[FrozenSetSubclass], Literal[frozenset], Unknown, Literal[object]]
+reveal_type(FrozenSetSubclass.__mro__)
+
+####################
+### `collections`
+
+class ChainMapSubclass(typing.ChainMap): ...
+
+# TODO: Should be (ChainMapSubclass, ChainMap, MutableMapping, Mapping, Collection, Sized, Iterable, Container, Generic, object)
+# revealed: tuple[Literal[ChainMapSubclass], Literal[ChainMap], Unknown, Literal[object]]
+reveal_type(ChainMapSubclass.__mro__)
+
+class CounterSubclass(typing.Counter): ...
+
+# TODO: Should be (CounterSubclass, Counter, dict, MutableMapping, Mapping, Collection, Sized, Iterable, Container, Generic, object)
+# revealed: tuple[Literal[CounterSubclass], Literal[Counter], Unknown, Literal[object]]
+reveal_type(CounterSubclass.__mro__)
 
-class E(typing.DefaultDict): ...
+class DefaultDictSubclass(typing.DefaultDict): ...
 
-reveal_type(E.__mro__)  # revealed: tuple[Literal[E], @Todo(Support for more typing aliases as base classes), Literal[object]]
+# TODO: Should be (DefaultDictSubclass, defaultdict, dict, MutableMapping, Mapping, Collection, Sized, Iterable, Container, Generic, object)
+# revealed: tuple[Literal[DefaultDictSubclass], Literal[defaultdict], Unknown, Literal[object]]
+reveal_type(DefaultDictSubclass.__mro__)
 
-class F(typing.OrderedDict): ...
+class DequeSubclass(typing.Deque): ...
 
-reveal_type(F.__mro__)  # revealed: tuple[Literal[F], @Todo(Support for more typing aliases as base classes), Literal[object]]
+# TODO: Should be (DequeSubclass, deque, MutableSequence, Sequence, Reversible, Collection, Sized, Iterable, Container, Generic, object)
+# revealed: tuple[Literal[DequeSubclass], Literal[deque], Unknown, Literal[object]]
+reveal_type(DequeSubclass.__mro__)
 
-class G(typing.Counter): ...
+class OrderedDictSubclass(typing.OrderedDict): ...
 
-reveal_type(G.__mro__)  # revealed: tuple[Literal[G], @Todo(Support for more typing aliases as base classes), Literal[object]]
+# TODO: Should be (OrderedDictSubclass, OrderedDict, dict, MutableMapping, Mapping, Collection, Sized, Iterable, Container, Generic, object)
+# revealed: tuple[Literal[OrderedDictSubclass], Literal[OrderedDict], Unknown, Literal[object]]
+reveal_type(OrderedDictSubclass.__mro__)
 ```

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

@@ -51,7 +51,7 @@ class D(TypeIs): ...  # error: [invalid-base]
 class E(Concatenate): ...  # error: [invalid-base]
 class F(Callable): ...
 
-reveal_type(F.__mro__)  # revealed: tuple[Literal[F], @Todo(Support for more typing aliases as base classes), Literal[object]]
+reveal_type(F.__mro__)  # revealed: tuple[Literal[F], @Todo(Support for Callable as a base class), Literal[object]]
 ```
 
 ## Subscriptability

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

@@ -67,6 +67,6 @@ def _(flag: bool):
             def __call__(self) -> int: ...
 
     a = NonCallable()
-    # error: "Object of type `Literal[1] | Literal[__call__]` is not callable (due to union element `Literal[1]`)"
-    reveal_type(a())  # revealed: Unknown | int
+    # error: "Object of type `Literal[__call__] | Literal[1]` is not callable (due to union element `Literal[1]`)"
+    reveal_type(a())  # revealed: int | Unknown
 ```

crates/red_knot_python_semantic/resources/mdtest/declaration/error.md

@@ -19,14 +19,17 @@ def _(flag: bool):
     x = 1  # error: [conflicting-declarations] "Conflicting declared types for `x`: str, int"
 ```
 
-## Partial declarations
+## Incompatible declarations for 2 (out of 3) types
 
 ```py
-def _(flag: bool):
-    if flag:
+def _(flag1: bool, flag2: bool):
+    if flag1:
+        x: str
+    elif flag2:
         x: int
 
-    x = 1  # error: [conflicting-declarations] "Conflicting declared types for `x`: Unknown, int"
+    # Here, the declared type for `x` is `int | str | Unknown`.
+    x = 1  # error: [conflicting-declarations] "Conflicting declared types for `x`: str, int"
 ```
 
 ## Incompatible declarations with bad assignment
@@ -42,3 +45,31 @@ def _(flag: bool):
     # error: [invalid-assignment]
     x = b"foo"
 ```
+
+## No errors
+
+Currently, we avoid raising the conflicting-declarations for the following cases:
+
+### Partial declarations
+
+```py
+def _(flag: bool):
+    if flag:
+        x: int
+
+    x = 1
+```
+
+### Partial declarations in try-except
+
+Refer to <https://github.com/astral-sh/ruff/issues/13966>
+
+```py
+def _():
+    try:
+        x: int = 1
+    except:
+        x = 2
+
+    x = 3
+```

crates/red_knot_python_semantic/resources/mdtest/import/basic.md

@@ -91,3 +91,16 @@ reveal_type(c.C)  # revealed: Literal[C]
 ```py path=a/b/c.py
 class C: ...
 ```
+
+## Unresolvable submodule imports
+
+```py
+# Topmost component resolvable, submodule not resolvable:
+import a.foo  # error: [unresolved-import] "Cannot resolve import `a.foo`"
+
+# Topmost component unresolvable:
+import b.foo  # error: [unresolved-import] "Cannot resolve import `b.foo`"
+```
+
+```py path=a/__init__.py
+```