support for evolving type-vars

Author: ikonst

mypy/plugins/attrs.py

@@ -965,17 +965,20 @@ def evolve_function_sig_callback(ctx: mypy.plugin.FunctionSigContext) -> Callabl
     inst_type = get_proper_type(inst_type)
     if isinstance(inst_type, AnyType):
         return ctx.default_signature  # evolve(Any, ....) -> Any
+    # We stringify it first, so that TypeVars maintain their name.
     inst_type_str = format_type_bare(inst_type)
+    upper_bound = inst_type.upper_bound if isinstance(inst_type, TypeVarType) else inst_type
     if not (
-        isinstance(inst_type, Instance) and (attrs_init_type := _get_attrs_init_type(inst_type))
+        isinstance(upper_bound, Instance)
+        and (attrs_init_type := _get_attrs_init_type(upper_bound))
     ):
         ctx.api.fail(
             f'Argument 1 to "evolve" has incompatible type "{inst_type_str}"; expected an attrs class',
             ctx.context,
         )
         return ctx.default_signature
 
-    attrs_init_type = expand_type_by_instance(attrs_init_type, inst_type)
+    attrs_init_type = expand_type_by_instance(attrs_init_type, upper_bound)
 
     # AttrClass.__init__ has the following signature (or similar, if having kw-only & defaults):
     #   def __init__(self, attr1: Type1, attr2: Type2) -> None:

test-data/unit/check-attr.test

@@ -1972,7 +1972,7 @@ reveal_type(ret)  # N: Revealed type is "Any"
 
 [case testEvolveGeneric]
 import attrs
-from typing import ClassVar, Generic, TypeVar
+from typing import Generic, TypeVar
 
 T = TypeVar('T')
 
@@ -1991,6 +1991,88 @@ reveal_type(a2)  # N: Revealed type is "__main__.A[builtins.int]"
 [builtins fixtures/attr.pyi]
 [typing fixtures/typing-medium.pyi]
 
+[case testEvolveTypeVarWithAttrsUpperBound]
+import attrs
+from typing import TypeVar
+
+
+@attrs.define
+class A:
+    x: int
+
+
+@attrs.define
+class B(A):
+    pass
+
+
+T = TypeVar('T', bound=A)
+
+
+def f(t: T) -> T:
+    t2 = attrs.evolve(t, x=42)
+    reveal_type(t2)  # N: Revealed type is "T`-1"
+    t3 = attrs.evolve(t, x='42')  # E: Argument "x" to "evolve" of "T" has incompatible type "str"; expected "int"
+    return t2
+
+f(A(x=42))
+f(B(x=42))
+
+[builtins fixtures/attr.pyi]
+[typing fixtures/typing-medium.pyi]
+
+[case testEvolveTypeVarWithAttrsGenericUpperBound]
+import attrs
+from typing import Generic, TypeVar
+
+Q = TypeVar('Q', bound=str)
+
+@attrs.define
+class A(Generic[Q]):
+    x: Q
+
+
+T = TypeVar('T', bound=A[str])
+
+
+def f(t: T) -> T:
+    t = attrs.evolve(t, x=42)  # E: Argument "x" to "evolve" of "T" has incompatible type "int"; expected "str"
+    return t
+
+f(A(x='42'))
+
+[builtins fixtures/attr.pyi]
+[typing fixtures/typing-medium.pyi]
+
+[case testEvolveTypeVarWithAttrsValueRestrictions]
+import attrs
+from typing import TypeVar
+
+@attrs.define
+class A:
+    x: int
+
+
+@attrs.define
+class B:
+    x: str  # conflicting with A.x
+
+
+T = TypeVar('T', A, B)
+
+
+def f(t: T) -> T:
+    t2 = attrs.evolve(t, x=42)  # E: Argument "x" to "evolve" of "B" has incompatible type "int"; expected "str"
+    reveal_type(t2)  # N: Revealed type is "__main__.A"  # N: Revealed type is "__main__.B"
+    t2 = attrs.evolve(t, x='42')  # E: Argument "x" to "evolve" of "A" has incompatible type "str"; expected "int"
+    return t2
+
+f(A(x=42))
+f(B(x='42'))
+
+[builtins fixtures/attr.pyi]
+[typing fixtures/typing-medium.pyi]
+
 [case testEvolveVariants]
 from typing import Any
 import attr