Pyright doesn't reject uses of Field for non-dataclasses

[adampauls]

Describe the bug pyright does not complain when a dataclasses.field is used as the default value of an attribute on a non-dataclass.

To Reproduce

import dataclasses

class NonDataClass:
    my_list: list[int] = dataclasses.field(default_factory=list)

    def add_item(self, item: int) -> None:
        self.my_list.append(item)

instance = NonDataClass()
instance.add_item(1)
assert instance.my_list == [1]

pyright issues no error.

Expected behavior
I should get the same error as if I used a literal of the wrong type (like "5"):

error: Expression of type "Field" cannot be assigned to declared type "list[int]"

VS Code extension or command-line
On command-line using pyright 1.1.302 and 1.1.303.

Additional context
Perhaps this behavior is by design? Maybe it's idiomatic in python to use dataclasses.field as a default value and do a manual isinstance(self.my_list, Field) check in __init__ or something?

[adampauls]

It appears that pyright is smart enough to narrow self.my_list in with this code:

    import dataclasses

    class NonDataClass:
        my_list: list[int] | dataclasses.Field[list[int]] = dataclasses.field(default_factory=list)

        def add_item(self, item: int) -> None:
            if isinstance(self.my_list, dataclasses.Field):
                assert isinstance(self.my_list.default_factory, Callable)
                self.my_list = self.my_list.default_factory()
            reveal_type(self.my_list)
            self.my_list.append(item)

    instance = NonDataClass()
    instance.add_item(1)
    assert instance.my_list == [1]

So I think it's reasonable to expect the user to explicitly declare the union type if they want to uses a dataclass.field on a non-dataclass?

[erictraut]

Pyright is doing the right thing here from a type checking standpoint. Pyright does apply special-case logic for dataclass.field if it is called within a dataclass field definition, but it otherwise doesn't apply any special meaning to it. It's a function, and it can be called anywhere you want. It's defined with overloads, and the applicable overload in this case returns an Any type, so its return type is compatible with list[int].

Not surprisingly, mypy also does not generate an error in this case.

[adampauls]

Oh my, I think it's even worse than that -- field just lies and says it returns list[int]

@overload
    def field(
        *,
        default_factory: Callable[[], _T],
        init: bool = True,
        repr: bool = True,
        hash: bool | None = None,
        compare: bool = True,
        metadata: Mapping[Any, Any] | None = None,
        kw_only: bool = ...,
    ) -> _T: ...

with the helpful comment:

# NOTE: Actual return type is 'Field[_T]', but we want to help type checkers
# to understand the magic that happens at runtime.