[red-knot] Detect overloads decorated with `@dataclass_transform`

[sharkdp]

We currently do not properly detect when an overload of a function is decorated with @dataclass_transform. See the existing test here. The goal of this ticket is to resolve the TODOs in this test.

See this discussion for a concrete plan on how to implement this.

[dhruvmanila]

I think this can be a "help wanted" issue now that we have FunctionType::to_overloaded in place.

From what I understand, this would mainly require updating the following site to first call to_overloaded and check whether there are any dataclass_transformer_params on any of the overloads, then check whether it is on the overload implementation.

ruff/crates/red_knot_python_semantic/src/types/call/bind.rs

Lines 718 to 739 in afc18ff

	if let Some(params) = function_type.dataclass_transformer_params(db) {
	// This is a call to a custom function that was decorated with `@dataclass_transformer`.
	// If this function was called with a keyword argument like `order=False`, we extract
	// the argument type and overwrite the corresponding flag in `dataclass_params` after
	// constructing them from the `dataclass_transformer`-parameter defaults.
	let mut dataclass_params = DataclassParams::from(params);
	if let Some(Some(Type::BooleanLiteral(order))) = callable_signature
	.iter()
	.nth(overload_index)
	.and_then(|signature| {
	let (idx, _) =
	signature.parameters().keyword_by_name("order")?;
	overload.parameter_types().get(idx)
	})
	{
	dataclass_params.set(DataclassParams::ORDER, *order);
	}
	overload.set_return_type(Type::DataclassDecorator(dataclass_params));
	}

[abhijeetbodas2001]

Hi @dhruvmanila, can I work on this?

[dhruvmanila]

@abhijeetbodas2001 Go for it, thanks.

[abhijeetbodas2001]

The spec also mentions this constraint:

If the function has overloads, the `dataclass_transform` decorator can be applied to the implementation
of the function or any one, but not more than one, of the overloads.

Is imposing this also part of this issue? I tested out mypy and pyright, but neither raised any errors for the below:

from typing_extensions import dataclass_transform, TypeVar, Callable, overload

T = TypeVar("T", bound=type)

@overload
@dataclass_transform()  # overload has it
def versioned_class(
    cls: T,
    *,
    version: int = 1,
) -> T: ...

@overload
def versioned_class(
    *,
    version: int = 1,
) -> Callable[[T], T]: ...

@dataclass_transform()  # implementation also has it
def versioned_class(
    cls: T | None = None,
    *,
    version: int = 1,
) -> T | Callable[[T], T]:
    raise NotImplementedError

For the case of dataclass_transform applied to more than one decorator also, neither of mypy or pyright raised any errors.

[sharkdp]

If the function has overloads, the `dataclass_transform` decorator can be applied to the implementation of the function or any one, but not more than one, of the overloads.

I also mentioned this in the test suite, but haven't written an explicit test, since I also noticed that other type checkers don't catch this. I think it's perfectly fine to postpone this for now.

[dhruvmanila]

I think it's perfectly fine to postpone this for now.

I agree with David here. Regardless, this check would be done elsewhere, in check_overload_functions that's being added in #17609.