Partially fixes issue 8625

mypy/plugins/attrs.py

@@ -6,6 +6,8 @@
 from typing_extensions import Final
 
 import mypy.plugin  # To avoid circular imports.
+from mypy.constraints import infer_constraints, SUBTYPE_OF
+from mypy.expandtype import expand_type
 from mypy.exprtotype import expr_to_unanalyzed_type, TypeTranslationError
 from mypy.fixup import lookup_qualified_stnode
 from mypy.nodes import (
@@ -18,6 +20,7 @@
 from mypy.plugins.common import (
     _get_argument, _get_bool_argument, _get_decorator_bool_argument, add_method
 )
+from mypy.solve import solve_constraints
 from mypy.types import (
     Type, AnyType, TypeOfAny, CallableType, NoneType, TypeVarDef, TypeVarType,
     Overloaded, UnionType, FunctionLike, get_proper_type
@@ -57,6 +60,43 @@ def __init__(self,
         self.is_attr_converters_optional = is_attr_converters_optional
 
 
+def expand_arg_type(
+        callable_type: CallableType,
+        target_type: Optional[Type],
+) -> Type:
+    # The result is based on the type of the first argument of the callable
+    arg_type = get_proper_type(callable_type.arg_types[0])
+    ret_type = get_proper_type(callable_type.ret_type)
+    target_type = get_proper_type(target_type)
+    if target_type is None:
+        target_type = AnyType(TypeOfAny.unannotated)
+
+    if ret_type == target_type or isinstance(ret_type, AnyType):
+        # If the callable has the exact same return type as the target
+        # we can directly return the type of the first argument.
+        # This is also the case if the return type is `Any`.
+        return arg_type
+
+    # Find the constraints on the type vars given that the result must be a
+    # subtype of the target type.
+    constraints = infer_constraints(ret_type, target_type, SUBTYPE_OF)
+    # When this code gets run, callable_type.variables has not yet been
+    # properly initialized, so we instead simply construct a set of all unique
+    # type var ids in the constraints
+    type_var_ids = list({const.type_var for const in constraints})
+    # Now we get the best solutions for these constraints
+    solutions = solve_constraints(type_var_ids, constraints)
+    type_map = {
+        tid: sol
+        for tid, sol in zip(type_var_ids, solutions)
+        if sol is not None
+    }
+
+    # Now we can use these solutions to expand the generic arg type into a
+    # concrete type
+    return expand_type(arg_type, type_map)
+
+
 class Attribute:
     """The value of an attr.ib() call."""
 
@@ -94,10 +134,11 @@ def argument(self, ctx: 'mypy.plugin.ClassDefContext') -> Argument:
             elif converter and converter.type:
                 converter_type = converter.type
 
+            orig_type = init_type
             init_type = None
             converter_type = get_proper_type(converter_type)
             if isinstance(converter_type, CallableType) and converter_type.arg_types:
-                init_type = ctx.api.anal_type(converter_type.arg_types[0])
+                init_type = ctx.api.anal_type(expand_arg_type(converter_type, orig_type))
             elif isinstance(converter_type, Overloaded):
                 types = []  # type: List[Type]
                 for item in converter_type.items():
@@ -107,7 +148,7 @@ def argument(self, ctx: 'mypy.plugin.ClassDefContext') -> Argument:
                         continue
                     if num_arg_types > 1 and any(kind == ARG_POS for kind in item.arg_kinds[1:]):
                         continue
-                    types.append(item.arg_types[0])
+                    types.append(expand_arg_type(item, orig_type))
                 # Make a union of all the valid types.
                 if types:
                     args = make_simplified_union(types)

test-data/unit/check-attr.test

@@ -714,6 +714,43 @@ reveal_type(A)  # N: Revealed type is 'def (x: builtins.int) -> __main__.A'
 reveal_type(A(15).x)  # N: Revealed type is 'builtins.str'
 [builtins fixtures/list.pyi]
 
+[case testAttrsUsingTupleConverter]
+from typing import Tuple
+import attr
+
+@attr.s
+class C:
+    t: Tuple[int, ...] = attr.ib(converter=tuple)
+
+o = C([1, 2, 3])
+o = C(['a'])  # E: List item 0 has incompatible type "str"; expected "int"
+[builtins fixtures/attr.pyi]
+
+[case testAttrsUsingListConverter]
+from typing import List
+import attr
+
+@attr.s
+class C:
+    t: List[int] = attr.ib(converter=list)
+
+o = C([1, 2, 3])
+o = C(['a'])  # E: List item 0 has incompatible type "str"; expected "int"
+[builtins fixtures/list.pyi]
+
+[case testAttrsUsingDictConverter]
+from typing import Dict
+import attr
+
+@attr.s
+class C(object):
+    values = attr.ib(type=Dict[str, int], converter=dict)
+
+
+C(values=[('a', 1), ('b', 2)])
+C(values=[(1, 'a')])  # E: List item 0 has incompatible type "Tuple[int, str]"; expected "Tuple[str, int]"
+[builtins fixtures/dict.pyi]
+
 [case testAttrsUsingConverterWithTypes]
 from typing import overload
 import attr

test-data/unit/fixtures/attr.pyi

@@ -1,5 +1,7 @@
 # Builtins stub used to support @attr.s tests.
-from typing import Union, overload
+from typing import Union, overload, Sequence, Generic, TypeVar, Iterable, \
+    Tuple, Iterator
+
 
 class object:
     def __init__(self) -> None: pass
@@ -22,6 +24,24 @@ class complex:
     @overload
     def __init__(self, real: str = ...) -> None: ...
 
+Tco = TypeVar('Tco', covariant=True)
+
+class tuple(Sequence[Tco], Generic[Tco]):
+    @overload
+    def __init__(self) -> None: pass
+    @overload
+    def __init__(self, x: Iterable[Tco]) -> None: pass
+    def __iter__(self) -> Iterator[Tco]: pass
+    def __contains__(self, item: object) -> bool: pass
+    def __getitem__(self, x: int) -> Tco: pass
+    def __rmul__(self, n: int) -> Tuple[Tco, ...]: pass
+    def __add__(self, x: Tuple[Tco, ...]) -> Tuple[Tco, ...]: pass
+    def count(self, obj: object) -> int: pass
+
+T = TypeVar('T')
+
+class list(Sequence[T], Generic[T]): pass
+
 class str: pass
 class unicode: pass
 class ellipsis: pass