infer types for unannotated pytest fixture parameters

pytest binds a test/fixture parameter by name from the fixture registry,
but only annotated parameters were checked against it — an unannotated one
was left as Unknown. it now takes the fixture's provided type

also extracts the parametrize marker recognition into pytest.rs so the
check pass and the new inference share one definition of what a marker is

Author: KotlinIsland

crates/ty_python_semantic/resources/mdtest/external/pytest.md

@@ -83,3 +83,63 @@ def test_add(a: int, b: int) -> None: ...
 @pytest.mark.parametrize("a, missing", [(1, 2)])  # error: [invalid-parametrize]
 def test_missing(a: int) -> None: ...
 ```
+
+## Unannotated parameters take the fixture's type
+
+An unannotated parameter is bound by pytest to the fixture of that name, so it takes the fixture's
+provided type rather than staying gradual — for a user fixture, for a builtin like `tmp_path`, and
+across a `conftest.py`.
+
+`conftest.py`:
+
+```py
+import pytest
+
+@pytest.fixture
+def db() -> str:
+    return "sqlite://"
+```
+
+`test_unannotated.py`:
+
+```py
+import pytest
+from typing import Iterator
+
+@pytest.fixture
+def port() -> int:
+    return 5432
+
+@pytest.fixture
+def handle() -> Iterator[bytes]:
+    yield b""
+
+def test_it(port, handle, db, tmp_path) -> None:
+    reveal_type(port)  # revealed: int
+    reveal_type(handle)  # revealed: bytes
+    reveal_type(db)  # revealed: str
+    reveal_type(tmp_path)  # revealed: Path
+    # the injected type is usable: a real attribute resolves, a bogus one is an error
+    reveal_type(tmp_path.name)  # revealed: str
+    port.bit_length()
+    port.no_such_method  # error: [unresolved-attribute]
+```
+
+## Parametrized names are arguments, not fixtures
+
+A name `@pytest.mark.parametrize` supplies comes from the marker's value rows, not the registry, so
+it is not fixture-typed even when a fixture of that name exists.
+
+`test_parametrized.py`:
+
+```py
+import pytest
+
+@pytest.fixture
+def value() -> int:
+    return 1
+
+@pytest.mark.parametrize("value", ["a", "b"])
+def test_it(value) -> None:
+    reveal_type(value)  # revealed: Unknown
+```

crates/ty_python_semantic/resources/mdtest/pytest.md

@@ -8,7 +8,8 @@ fixtures and `parametrize` — against the real package.
 pytest fills a test or fixture parameter by *name* from a registry: the function's own module, then
 the `conftest.py` chain, then builtin fixtures. A parameter annotation that disagrees with the
 resolved fixture's type is an error; the fixture's provided type is its return annotation, with a
-yield fixture's `Iterator[T]` / `Generator[T, ...]` unwrapped to `T`.
+yield fixture's `Iterator[T]` / `Generator[T, ...]` unwrapped to `T`. An *unannotated* parameter
+takes that provided type instead of the implicit `Unknown` an ordinary parameter would get.
 
 ## Fixture resolution and type checking
 
@@ -199,3 +200,270 @@ def fixture(function: None = ..., *, scope: str = ..., name: str | None = None)
 def test_it(missing) -> None:  # error: [unknown-fixture]
     ...
 ```
+
+## Unannotated parameters take the fixture's type
+
+An unannotated parameter is bound by pytest to the fixture of the same name, so the body sees that
+fixture's provided type — including through a rename, a yield fixture's unwrapping, and the
+`conftest.py` chain. A name that resolves to no fixture stays gradual, as does one whose fixture has
+no derivable type.
+
+```toml
+[environment]
+python = "/.venv"
+```
+
+`/.venv/<path-to-site-packages>/pytest/__init__.pyi`:
+
+```pyi
+from _pytest.fixtures import fixture as fixture
+```
+
+`/.venv/<path-to-site-packages>/_pytest/__init__.pyi`:
+
+```pyi
+```
+
+`/.venv/<path-to-site-packages>/_pytest/fixtures.pyi`:
+
+```pyi
+from typing import Any, Callable, overload
+
+class FixtureFunctionDefinition: ...
+
+class FixtureFunctionMarker:
+    def __call__(self, function: Callable[..., Any]) -> FixtureFunctionDefinition: ...
+
+@overload
+def fixture(function: Callable[..., Any], *, scope: str = ..., name: str | None = None) -> FixtureFunctionDefinition: ...
+@overload
+def fixture(function: None = ..., *, scope: str = ..., name: str | None = None) -> FixtureFunctionMarker: ...
+```
+
+`conftest.py`:
+
+```py
+import pytest
+
+@pytest.fixture
+def from_conftest() -> bytes:
+    return b""
+```
+
+`test_unannotated.py`:
+
+```py
+import pytest
+from typing import Iterator
+
+@pytest.fixture
+def number() -> int:
+    return 1
+
+@pytest.fixture(name="renamed")
+def _make_text() -> str:
+    return "x"
+
+@pytest.fixture
+def yielded() -> Iterator[bool]:
+    yield True
+
+@pytest.fixture
+def untyped():
+    return object()
+
+def test_it(number, renamed, yielded, from_conftest, untyped, missing) -> None:  # error: [unknown-fixture]
+    reveal_type(number)  # revealed: int
+    reveal_type(renamed)  # revealed: str
+    reveal_type(yielded)  # revealed: bool
+    reveal_type(from_conftest)  # revealed: bytes
+    reveal_type(untyped)  # revealed: Unknown
+    reveal_type(missing)  # revealed: Unknown
+```
+
+## A fixture's own parameters take fixture types
+
+Fixtures request fixtures the same way tests do, so an unannotated parameter of a `@pytest.fixture`
+function is typed from the registry too — including when the fixture it requests is defined later in
+the module.
+
+```toml
+[environment]
+python = "/.venv"
+```
+
+`/.venv/<path-to-site-packages>/pytest/__init__.pyi`:
+
+```pyi
+from _pytest.fixtures import fixture as fixture
+```
+
+`/.venv/<path-to-site-packages>/_pytest/__init__.pyi`:
+
+```pyi
+```
+
+`/.venv/<path-to-site-packages>/_pytest/fixtures.pyi`:
+
+```pyi
+from typing import Any, Callable, overload
+
+class FixtureFunctionDefinition: ...
+
+class FixtureFunctionMarker:
+    def __call__(self, function: Callable[..., Any]) -> FixtureFunctionDefinition: ...
+
+@overload
+def fixture(function: Callable[..., Any], *, scope: str = ..., name: str | None = None) -> FixtureFunctionDefinition: ...
+@overload
+def fixture(function: None = ..., *, scope: str = ..., name: str | None = None) -> FixtureFunctionMarker: ...
+```
+
+`test_chained.py`:
+
+```py
+import pytest
+
+@pytest.fixture
+def outer(inner) -> str:
+    reveal_type(inner)  # revealed: int
+    return str(inner)
+
+@pytest.fixture
+def inner() -> int:
+    return 1
+
+def test_it(outer) -> None:
+    reveal_type(outer)  # revealed: str
+```
+
+## Parametrized names are arguments, not fixtures
+
+`@pytest.mark.parametrize` supplies a name from its value rows rather than from the fixture
+registry, so a parametrized parameter is not fixture-typed even when a fixture of that name exists.
+
+```toml
+[environment]
+python = "/.venv"
+```
+
+`/.venv/<path-to-site-packages>/pytest/__init__.pyi`:
+
+```pyi
+from _pytest.fixtures import fixture as fixture
+from _pytest.mark.structures import MarkGenerator as MarkGenerator
+
+mark: MarkGenerator
+```
+
+`/.venv/<path-to-site-packages>/_pytest/__init__.pyi`:
+
+```pyi
+```
+
+`/.venv/<path-to-site-packages>/_pytest/mark/__init__.pyi`:
+
+```pyi
+```
+
+`/.venv/<path-to-site-packages>/_pytest/mark/structures.pyi`:
+
+```pyi
+from typing import Any
+
+class MarkDecorator:
+    def __call__(self, *args: Any, **kwargs: Any) -> Any: ...
+
+class MarkGenerator:
+    def __getattr__(self, name: str) -> MarkDecorator: ...
+```
+
+`/.venv/<path-to-site-packages>/_pytest/fixtures.pyi`:
+
+```pyi
+from typing import Any, Callable, overload
+
+class FixtureFunctionDefinition: ...
+
+class FixtureFunctionMarker:
+    def __call__(self, function: Callable[..., Any]) -> FixtureFunctionDefinition: ...
+
+@overload
+def fixture(function: Callable[..., Any], *, scope: str = ..., name: str | None = None) -> FixtureFunctionDefinition: ...
+@overload
+def fixture(function: None = ..., *, scope: str = ..., name: str | None = None) -> FixtureFunctionMarker: ...
+```
+
+`test_parametrized.py`:
+
+```py
+import pytest
+
+@pytest.fixture
+def value() -> int:
+    return 1
+
+@pytest.mark.parametrize("value", ["a", "b"])
+def test_it(value) -> None:
+    # supplied by the marker, so the same-named fixture does not apply
+    reveal_type(value)  # revealed: Unknown
+
+@pytest.mark.parametrize("other", ["a", "b"])
+def test_mixed(other, value) -> None:
+    reveal_type(other)  # revealed: Unknown
+    reveal_type(value)  # revealed: int
+```
+
+## Ordinary functions are untouched
+
+A function pytest does not manage keeps the ordinary rules for an unannotated parameter, even when a
+fixture of that name is in scope.
+
+```toml
+[environment]
+python = "/.venv"
+```
+
+`/.venv/<path-to-site-packages>/pytest/__init__.pyi`:
+
+```pyi
+from _pytest.fixtures import fixture as fixture
+```
+
+`/.venv/<path-to-site-packages>/_pytest/__init__.pyi`:
+
+```pyi
+```
+
+`/.venv/<path-to-site-packages>/_pytest/fixtures.pyi`:
+
+```pyi
+from typing import Any, Callable, overload
+
+class FixtureFunctionDefinition: ...
+
+class FixtureFunctionMarker:
+    def __call__(self, function: Callable[..., Any]) -> FixtureFunctionDefinition: ...
+
+@overload
+def fixture(function: Callable[..., Any], *, scope: str = ..., name: str | None = None) -> FixtureFunctionDefinition: ...
+@overload
+def fixture(function: None = ..., *, scope: str = ..., name: str | None = None) -> FixtureFunctionMarker: ...
+```
+
+`test_ordinary.py`:
+
+```py
+import pytest
+
+@pytest.fixture
+def number() -> int:
+    return 1
+
+# a helper, not a test: pytest never calls it, so `number` is an ordinary parameter
+def helper(number) -> None:
+    reveal_type(number)  # revealed: Unknown
+
+def test_it() -> None:
+    helper("anything")
+```