Fix generic function overloading with tuple types

Fixes #1595.

There were actually two issues:

* Erasing tuple types was incorrect, as the fallback type was not erased.
* Some tuple types got generated without a type argument, even though
  a uniform tuple type is internally represented as instance type tuple[t].

Similar issues might still arise in other contexts but at least this is
improves things a little.

Also, we generate fallback types that are like Tuple[Any, ...]. We could
potentially generate a more precise fallback type, but that would potentially
require joins and I'm not sure if we can use them during semantic analysis.

Author: JukkaL

mypy/erasetype.py

@@ -67,7 +67,7 @@ def visit_overloaded(self, t: Overloaded) -> Type:
         return t.items()[0].accept(self)
 
     def visit_tuple_type(self, t: TupleType) -> Type:
-        return t.fallback
+        return t.fallback.accept(self)
 
     def visit_union_type(self, t: UnionType) -> Type:
         return AnyType()        # XXX: return underlying type if only one?

mypy/test/data/check-overloading.test

@@ -678,3 +678,20 @@ def f(x: int) -> None: pass
 def f(x: B) -> str: pass # E: Overloaded function signatures 2 and 3 overlap with incompatible return types
 @overload
 def f(x: A) -> int: pass
+
+[case testOverloadWithTupleMatchingTypeVar]
+from typing import TypeVar, Generic, Tuple, overload
+
+T = TypeVar('T')
+
+class A(Generic[T]):
+    @overload
+    def f(self, arg: T) -> None:
+        pass
+    @overload
+    def f(self, arg: T, default: int) -> None:
+        pass
+
+b = A()  # type: A[Tuple[int, int]]
+b.f((0, 0))
+b.f((0, '')) # E: Argument 1 to "f" of "A" has incompatible type "Tuple[int, str]"; expected "Tuple[int, int]"

mypy/typeanal.py

@@ -100,8 +100,7 @@ def visit_unbound_type(self, t: UnboundType) -> Type:
                     node = self.lookup_fqn_func('builtins.tuple')
                     info = cast(TypeInfo, node.node)
                     return Instance(info, [t.args[0].accept(self)], t.line)
-                return TupleType(self.anal_array(t.args),
-                                 self.builtin_type('builtins.tuple'))
+                return self.tuple_type(self.anal_array(t.args))
             elif fullname == 'typing.Union':
                 items = self.anal_array(t.args)
                 items = [item for item in items if not isinstance(item, Void)]
@@ -191,7 +190,7 @@ def visit_tuple_type(self, t: TupleType) -> Type:
         if star_count > 1:
             self.fail('At most one star type allowed in a tuple', t)
             return AnyType()
-        fallback = t.fallback if t.fallback else self.builtin_type('builtins.tuple')
+        fallback = t.fallback if t.fallback else self.builtin_type('builtins.tuple', [AnyType()])
         return TupleType(self.anal_array(t.items), fallback, t.line)
 
     def visit_star_type(self, t: StarType) -> Type:
@@ -257,10 +256,13 @@ def anal_var_defs(self, var_defs: List[TypeVarDef]) -> List[TypeVarDef]:
                                 vd.line))
         return a
 
-    def builtin_type(self, fully_qualified_name: str) -> Instance:
+    def builtin_type(self, fully_qualified_name: str, args: List[Type] = None) -> Instance:
         node = self.lookup_fqn_func(fully_qualified_name)
         info = cast(TypeInfo, node.node)
-        return Instance(info, [])
+        return Instance(info, args or [])
+
+    def tuple_type(self, items: List[Type]) -> TupleType:
+        return TupleType(items, fallback=self.builtin_type('builtins.tuple', [AnyType()]))
 
 
 class TypeAnalyserPass3(TypeVisitor[None]):