)

def_fail_not_dataclass(ctx:FunctionSigContext,t:Type,parent_t:Type)->None:

t_name=format_type_bare(t,ctx.api.options)

ifparent_tist:

msg= (

ifisinstance(t,TypeVarType)

)

else:

pt_name=format_type_bare(parent_t,ctx.api.options)

msg= (

ifisinstance(t,TypeVarType)

)

ctx.api.fail(msg,ctx.context)

def_get_expanded_dataclasses_fields(

ctx:FunctionSigContext,typ:ProperType,display_typ:ProperType,parent_typ:ProperType

)->list[CallableType]|None:

ifisinstance(typ,AnyType):

elifisinstance(typ,UnionType):

ifisinstance(typ,UnionType):

ret:list[CallableType]|None= []

foritemintyp.relevant_items():

item=get_proper_type(item)

elifisinstance(typ,Instance):

replace_sym=typ.type.get_method(_INTERNAL_REPLACE_SYM_NAME)

ifreplace_symisNone:

_fail_not_dataclass(ctx,display_typ,parent_typ)

replace_sig=replace_sym.type

assertisinstance(replace_sig,ProperType)

assertisinstance(replace_sig,CallableType)

return [expand_type_by_instance(replace_sig,typ)]

else:

_fail_not_dataclass(ctx,display_typ,parent_typ)

a2 = replace(a, q='42') # E: Argument "q" to "replace" of "A" has incompatible type "str"; expected "int"

reveal_type(a2) # N: Revealed type is "__main__.A"

[builtins fixtures/tuple.pyi]

[case testReplaceUnion]

from typing import Generic, Union, TypeVar

from dataclasses import dataclass, replace, InitVar

_ = replace(a_or_b, x=42, y=True, w={}, init_var=42) # E: Argument "w" to "replace" of "Union[A[int], B]" has incompatible type "Dict[<nothing>, <nothing>]"; expected <nothing>

_ = replace(a_or_b, y=42, init_var=42) # E: Argument "y" to "replace" of "Union[A[int], B]" has incompatible type "int"; expected "bool"

[builtins fixtures/dataclasses.pyi]

[builtins fixtures/tuple.pyi]

[case testReplaceUnionOfTypeVar]

from typing import Generic, Union, TypeVar

TB = TypeVar('TB', bound=B)

def f(b_or_t: Union[TA, TB, int]) -> None:

a2 = replace(b_or_t) # E: Argument 1 to "replace" has type "Union[TA, TB, int]" whose item "TB" is not bound to a dataclass # E: Argument 1 to "replace" has incompatible type "Union[TA, TB, int]" whose item "int" is not a dataclass

a2 = replace(b_or_t) # E: Value of type variable "_DataclassT" of "replace" cannot be "Union[TA, TB, int]"

[builtins fixtures/tuple.pyi]

[case testReplaceTypeVarBoundNotDataclass]

from dataclasses import dataclass, replace

TUnion = TypeVar('TUnion', bound=Union[str, int])

def f1(t: TInt) -> None:

_ = replace(t, x=42) # E:Argument 1 to "replace" has a variable type "TInt" not bound to a dataclass

_ = replace(t, x=42) # E:Value of type variable "_DataclassT" of "replace" cannot be "TInt"

def f2(t: TAny) -> TAny:

return replace(t, x='spam') # E:Argument 1 to "replace" has a variable type "TAny" not bound to a dataclass

return replace(t, x='spam') # E:Value of type variable "_DataclassT" of "replace" cannot be "TAny"

def f3(t: TNone) -> TNone:

return replace(t, x='spam') # E:Argument 1 to "replace" has a variable type "TNone" not bound to a dataclass

return replace(t, x='spam') # E:Value of type variable "_DataclassT" of "replace" cannot be "TNone"

def f4(t: TUnion) -> TUnion:

return replace(t, x='spam') # E: Argument 1 to "replace" has incompatible type "TUnion" whose item "str" is not a dataclass # E: Argument 1 to "replace" has incompatible type "TUnion" whose item "int" is not a dataclass

return replace(t, x='spam') # E: Value of type variable "_DataclassT" of "replace" cannot be "TUnion"

[builtins fixtures/tuple.pyi]

[case testReplaceTypeVarBound]

from dataclasses import dataclass, replace

f(A(x=42))

f(B(x=42))

[builtins fixtures/tuple.pyi]

[case testReplaceAny]

from dataclasses import replace

from typing import Any

a2 = replace(a)

reveal_type(a2) # N: Revealed type is "Any"

[builtins fixtures/tuple.pyi]

[case testReplaceNotDataclass]

from dataclasses import replace

replace(5) # E:Argument 1 to "replace" has incompatible type "int"; expected a dataclass

replace(5) # E:Value of type variable "_DataclassT" of "replace" cannot be "int"

class C:

pass

replace(C()) # E:Argument 1 to "replace" has incompatible type "C"; expected a dataclass

replace(C()) # E:Value of type variable "_DataclassT" of "replace" cannot be "C"

replace(None) # E: Argument 1 to "replace" has incompatible type "None"; expected a dataclass

replace(None) # E: Value of type variable "_DataclassT" of "replace" cannot be "None"

[builtins fixtures/tuple.pyi]

[case testReplaceIsDataclass]

from dataclasses import is_dataclass, replace

def f(x: object) -> None:

if is_dataclass(x) and not isinstance(x, type):

y = replace(x)

[builtins fixtures/tuple.pyi]

[case testReplaceGeneric]

from dataclasses import dataclass, replace, InitVar

a2 = replace(a, x='42') # E: Argument "x" to "replace" of "A[int]" has incompatible type "str"; expected "int"

reveal_type(a2) # N: Revealed type is "__main__.A[builtins.int]"

[builtins fixtures/tuple.pyi]

[case testPostInitCorrectSignature]

from typing import Any, Generic, TypeVar, Callable, Self

from dataclasses import dataclass, InitVar

fromtypingimportProtocol,TypeVar,Iterable

fromtypingimportAny,ClassVar,Protocol,TypeVar,Iterable

_KT=TypeVar("_KT")

_VT_co=TypeVar("_VT_co",covariant=True)

classSupportsKeysAndGetItem(Protocol[_KT,_VT_co]):

defkeys(self)->Iterable[_KT]:pass

def__getitem__(self,__key:_KT)->_VT_co:pass

classDataclassInstance(Protocol):

__dataclass_fields__:ClassVar[dict[str,Field[Any]]]

fromtypingimportAny,Callable,Generic,Mapping,Optional,TypeVar,overload,Type

fromtypingimportAny,Callable,Generic,Literal,Mapping,Optional,TypeVar,overload,Type

_T=TypeVar('_T')

_DataclassT=TypeVar("_DataclassT",bound=DataclassInstance)

classInitVar(Generic[_T]):

...

classField(Generic[_T]):pass

defreplace(__obj:_T,**changes:Any)->_T: ...

defis_dataclass(obj:DataclassInstance)->Literal[True]: ...

defis_dataclass(obj:type)->TypeGuard[type[DataclassInstance]]: ...

defis_dataclass(obj:object)->TypeGuard[DataclassInstance|type[DataclassInstance]]: ...

defreplace(__obj:_DataclassT,**changes:Any)->_DataclassT: ...