Merge branch 'main' into dcreager/legacy-class

* main:
  [red-knot] Preliminary `NamedTuple` support (#17738)
  [red-knot] Add tests for classes that have incompatible `__new__` and `__init__` methods (#17747)
  Update dependency vite to v6.2.7 (#17746)
  [red-knot] Update call binding to return all matching overloads (#17618)
  [`airflow`] apply Replacement::AutoImport to `AIR312` (#17570)
  [`ruff`] Add fix safety section (`RUF028`) (#17722)
  [syntax-errors] Detect single starred expression assignment `x = *y` (#17624)
  py-fuzzer: fix minimization logic when `--only-new-bugs` is passed (#17739)
  Fix example syntax for pydocstyle ignore_var_parameters option (#17740)
  [red-knot] Update salsa to prevent panic in custom panic-handler (#17742)
  [red-knot] Ban direct instantiation of generic protocols as well as non-generic ones (#17741)
  [red-knot] Lookup of `__new__` (#17733)
  [red-knot] Check decorator consistency on overloads (#17684)
  [`flake8-use-pathlib`] Avoid suggesting `Path.iterdir()` for `os.listdir` with file descriptor (`PTH208`) (#17715)
  [red-knot] Check overloads without an implementation (#17681)
  Expand Semantic Syntax Coverage (#17725)
  [red-knot] Check for invalid overload usages (#17609)

Author: dcreager

Cargo.lock

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

Cargo.toml

@@ -1,25 +1,25 @@
 # Constructor
 
-When classes are instantiated, Python calls the meta-class `__call__` method, which can either be
-customized by the user or `type.__call__` is used.
+When classes are instantiated, Python calls the metaclass's `__call__` method. The metaclass of most
+Python classes is the class `builtins.type`.
 
-The latter calls the `__new__` method of the class, which is responsible for creating the instance
-and then calls the `__init__` method on the resulting instance to initialize it with the same
-arguments.
+`type.__call__` calls the `__new__` method of the class, which is responsible for creating the
+instance. `__init__` is then called on the constructed instance with the same arguments that were
+passed to `__new__`.
 
-Both `__new__` and `__init__` are looked up using full descriptor protocol, but `__new__` is then
-called as an implicit static, rather than bound method with `cls` passed as the first argument.
-`__init__` has no special handling, it is fetched as bound method and is called just like any other
-dunder method.
+Both `__new__` and `__init__` are looked up using the descriptor protocol, i.e., `__get__` is called
+if these attributes are descriptors. `__new__` is always treated as a static method, i.e., `cls` is
+passed as the first argument. `__init__` has no special handling; it is fetched as a bound method
+and called just like any other dunder method.
 
 `type.__call__` does other things too, but this is not yet handled by us.
 
 Since every class has `object` in it's MRO, the default implementations are `object.__new__` and
 `object.__init__`. They have some special behavior, namely:
 
-- If neither `__new__` nor `__init__` are defined anywhere in the MRO of class (except for `object`)
-    \- no arguments are accepted and `TypeError` is raised if any are passed.
-- If `__new__` is defined, but `__init__` is not - `object.__init__` will allow arbitrary arguments!
+- If neither `__new__` nor `__init__` are defined anywhere in the MRO of class (except for
+    `object`), no arguments are accepted and `TypeError` is raised if any are passed.
+- If `__new__` is defined but `__init__` is not, `object.__init__` will allow arbitrary arguments!
 
 As of today there are a number of behaviors that we do not support:
 
@@ -146,6 +146,25 @@ reveal_type(Foo())  # revealed: Foo
 
 ### Possibly Unbound
 
+#### Possibly unbound `__new__` method
+
+```py
+def _(flag: bool) -> None:
+    class Foo:
+        if flag:
+            def __new__(cls):
+                return object.__new__(cls)
+
+    # error: [call-possibly-unbound-method]
+    reveal_type(Foo())  # revealed: Foo
+
+    # error: [call-possibly-unbound-method]
+    # error: [too-many-positional-arguments]
+    reveal_type(Foo(1))  # revealed: Foo
+```
+
+#### Possibly unbound `__call__` on `__new__` callable
+
 ```py
 def _(flag: bool) -> None:
     class Callable:
@@ -323,3 +342,86 @@ reveal_type(Foo(1))  # revealed: Foo
 # error: [too-many-positional-arguments] "Too many positional arguments to bound method `__init__`: expected 1, got 2"
 reveal_type(Foo(1, 2))  # revealed: Foo
 ```
+
+### Incompatible signatures
+
+```py
+import abc
+
+class Foo:
+    def __new__(cls) -> "Foo":
+        return object.__new__(cls)
+
+    def __init__(self, x):
+        self.x = 42
+
+# error: [missing-argument] "No argument provided for required parameter `x` of bound method `__init__`"
+reveal_type(Foo())  # revealed: Foo
+
+# error: [too-many-positional-arguments] "Too many positional arguments to function `__new__`: expected 0, got 1"
+reveal_type(Foo(42))  # revealed: Foo
+
+class Foo2:
+    def __new__(cls, x) -> "Foo2":
+        return object.__new__(cls)
+
+    def __init__(self):
+        pass
+
+# error: [missing-argument] "No argument provided for required parameter `x` of function `__new__`"
+reveal_type(Foo2())  # revealed: Foo2
+
+# error: [too-many-positional-arguments] "Too many positional arguments to bound method `__init__`: expected 0, got 1"
+reveal_type(Foo2(42))  # revealed: Foo2
+
+class Foo3(metaclass=abc.ABCMeta):
+    def __new__(cls) -> "Foo3":
+        return object.__new__(cls)
+
+    def __init__(self, x):
+        self.x = 42
+
+# error: [missing-argument] "No argument provided for required parameter `x` of bound method `__init__`"
+reveal_type(Foo3())  # revealed: Foo3
+
+# error: [too-many-positional-arguments] "Too many positional arguments to function `__new__`: expected 0, got 1"
+reveal_type(Foo3(42))  # revealed: Foo3
+
+class Foo4(metaclass=abc.ABCMeta):
+    def __new__(cls, x) -> "Foo4":
+        return object.__new__(cls)
+
+    def __init__(self):
+        pass
+
+# error: [missing-argument] "No argument provided for required parameter `x` of function `__new__`"
+reveal_type(Foo4())  # revealed: Foo4
+
+# error: [too-many-positional-arguments] "Too many positional arguments to bound method `__init__`: expected 0, got 1"
+reveal_type(Foo4(42))  # revealed: Foo4
+```
+
+### Lookup of `__new__`
+
+The `__new__` method is always invoked on the class itself, never on the metaclass. This is
+different from how other dunder methods like `__lt__` are implicitly called (always on the
+meta-type, never on the type itself).
+
+```py
+from typing_extensions import Literal
+
+class Meta(type):
+    def __new__(mcls, name, bases, namespace, /, **kwargs):
+        return super().__new__(mcls, name, bases, namespace)
+
+    def __lt__(cls, other) -> Literal[True]:
+        return True
+
+class C(metaclass=Meta): ...
+
+# No error is raised here, since we don't implicitly call `Meta.__new__`
+reveal_type(C())  # revealed: C
+
+# Meta.__lt__ is implicitly called here:
+reveal_type(C < C)  # revealed: Literal[True]
+```

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

@@ -205,7 +205,7 @@ reveal_type(IntOrStr.__or__)  # revealed: bound method typing.TypeAliasType.__or
 
 The `__get__` method on `types.FunctionType` has the following overloaded signature in typeshed:
 
-```py
+```pyi
 from types import FunctionType, MethodType
 from typing import overload
 

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

@@ -130,6 +130,62 @@ async def g():
 (x async for x in g())
 ```
 
+## Rebound comprehension variable
+
+Walrus operators cannot rebind variables already in use as iterators:
+
+```py
+# error: [invalid-syntax] "assignment expression cannot rebind comprehension variable"
+[x := 2 for x in range(10)]
+
+# error: [invalid-syntax] "assignment expression cannot rebind comprehension variable"
+{y := 5 for y in range(10)}
+```
+
+## Multiple case assignments
+
+Variable names in pattern matching must be unique within a single pattern:
+
+```toml
+[environment]
+python-version = "3.10"
+```
+
+```py
+x = [1, 2]
+match x:
+    # error: [invalid-syntax] "multiple assignments to name `a` in pattern"
+    case [a, a]:
+        pass
+    case _:
+        pass
+
+d = {"key": "value"}
+match d:
+    # error: [invalid-syntax] "multiple assignments to name `b` in pattern"
+    case {"key": b, "other": b}:
+        pass
+```
+
+## Duplicate type parameter
+
+Type parameter names must be unique in a generic class or function definition:
+
+```toml
+[environment]
+python-version = "3.12"
+```
+
+```py
+# error: [invalid-syntax] "duplicate type parameter"
+class C[T, T]:
+    pass
+
+# error: [invalid-syntax] "duplicate type parameter"
+def f[X, Y, X]():
+    pass
+```
+
 ## `await` outside async function
 
 This error includes `await`, `async for`, `async with`, and `async` comprehensions.

crates/red_knot_python_semantic/resources/mdtest/diagnostics/semantic_syntax_errors.md

@@ -0,0 +1,120 @@
+# `NamedTuple`
+
+`NamedTuple` is a type-safe way to define named tuples — a tuple where each field can be accessed by
+name, and not just by its numeric position within the tuple:
+
+## `typing.NamedTuple`
+
+### Basics
+
+```py
+from typing import NamedTuple
+
+class Person(NamedTuple):
+    id: int
+    name: str
+    age: int | None = None
+
+alice = Person(1, "Alice", 42)
+alice = Person(id=1, name="Alice", age=42)
+bob = Person(2, "Bob")
+bob = Person(id=2, name="Bob")
+
+reveal_type(alice.id)  # revealed: int
+reveal_type(alice.name)  # revealed: str
+reveal_type(alice.age)  # revealed: int | None
+
+# TODO: These should reveal the types of the fields
+reveal_type(alice[0])  # revealed: Unknown
+reveal_type(alice[1])  # revealed: Unknown
+reveal_type(alice[2])  # revealed: Unknown
+
+# error: [missing-argument]
+Person(3)
+
+# error: [too-many-positional-arguments]
+Person(3, "Eve", 99, "extra")
+
+# error: [invalid-argument-type]
+Person(id="3", name="Eve")
+```
+
+Alternative functional syntax:
+
+```py
+Person2 = NamedTuple("Person", [("id", int), ("name", str)])
+alice2 = Person2(1, "Alice")
+
+# TODO: should be an error
+Person2(1)
+
+reveal_type(alice2.id)  # revealed: @Todo(GenericAlias instance)
+reveal_type(alice2.name)  # revealed: @Todo(GenericAlias instance)
+```
+
+### Multiple Inheritance
+
+Multiple inheritance is not supported for `NamedTuple` classes:
+
+```py
+from typing import NamedTuple
+
+# This should ideally emit a diagnostic
+class C(NamedTuple, object):
+    id: int
+    name: str
+```
+
+### Inheriting from a `NamedTuple`
+
+Inheriting from a `NamedTuple` is supported, but new fields on the subclass will not be part of the
+synthesized `__new__` signature:
+
+```py
+from typing import NamedTuple
+
+class User(NamedTuple):
+    id: int
+    name: str
+
+class SuperUser(User):
+    level: int
+
+# This is fine:
+alice = SuperUser(1, "Alice")
+reveal_type(alice.level)  # revealed: int
+
+# This is an error because `level` is not part of the signature:
+# error: [too-many-positional-arguments]
+alice = SuperUser(1, "Alice", 3)
+```
+
+### Generic named tuples
+
+```toml
+[environment]
+python-version = "3.12"
+```
+
+```py
+from typing import NamedTuple
+
+class Property[T](NamedTuple):
+    name: str
+    value: T
+
+# TODO: this should be supported (no error, revealed type of `Property[float]`)
+# error: [invalid-argument-type]
+reveal_type(Property("height", 3.4))  # revealed: Property[Unknown]
+```
+
+## `collections.namedtuple`
+
+```py
+from collections import namedtuple
+
+Person = namedtuple("Person", ["id", "name", "age"], defaults=[None])
+
+alice = Person(1, "Alice", 42)
+bob = Person(2, "Bob")
+```