Never put None in TupleType items (#4051)

Fixes #4046

The root cause for the crash is that None was put in TupleType items if the corresponding lvalue is a definition. Then the crash happens when this TupleType is used as a context for rvalue type inference. The solution is to put UninhabitedType in such cases, so that inference will fall back on using argument types instead.

Author: ilevkivskyi

mypy/checker.py

@@ -1769,7 +1769,10 @@ def check_lvalue(self, lvalue: Lvalue) -> Tuple[Optional[Type],
             lvalue_type = self.expr_checker.analyze_ref_expr(lvalue, lvalue=True)
             self.store_type(lvalue, lvalue_type)
         elif isinstance(lvalue, TupleExpr) or isinstance(lvalue, ListExpr):
-            types = [self.check_lvalue(sub_expr)[0] for sub_expr in lvalue.items]
+            types = [self.check_lvalue(sub_expr)[0] or
+                     # This type will be used as a context for further inference of rvalue,
+                     # we put Uninhabited if there is no information available from lvalue.
+                     UninhabitedType() for sub_expr in lvalue.items]
             lvalue_type = TupleType(types, self.named_type('builtins.tuple'))
         else:
             lvalue_type = self.expr_checker.accept(lvalue)

mypy/checkexpr.py

@@ -769,7 +769,7 @@ def infer_function_type_arguments_using_context(
         # Only substitute non-Uninhabited and non-erased types.
         new_args = []  # type: List[Optional[Type]]
         for arg in args:
-            if isinstance(arg, UninhabitedType) or has_erased_component(arg):
+            if has_uninhabited_component(arg) or has_erased_component(arg):
                 new_args.append(None)
             else:
                 new_args.append(arg)
@@ -2768,6 +2768,19 @@ def visit_erased_type(self, t: ErasedType) -> bool:
         return True
 
 
+def has_uninhabited_component(t: Optional[Type]) -> bool:
+    return t is not None and t.accept(HasUninhabitedComponentsQuery())
+
+
+class HasUninhabitedComponentsQuery(types.TypeQuery[bool]):
+    """Visitor for querying whether a type has an UninhabitedType component."""
+    def __init__(self) -> None:
+        super().__init__(any)
+
+    def visit_uninhabited_type(self, t: UninhabitedType) -> bool:
+        return True
+
+
 def overload_arg_similarity(actual: Type, formal: Type) -> int:
     """Return if caller argument (actual) is compatible with overloaded signature arg (formal).
 

test-data/unit/check-inference.test

@@ -1927,3 +1927,18 @@ x = None
 (x, x) = f('')
 reveal_type(x) # E: Revealed type is 'builtins.str'
 [out]
+
+[case testInferenceNestedTuplesFromGenericIterable]
+from typing import Tuple, TypeVar
+
+T = TypeVar('T')
+
+def make_tuple(elem: T) -> Tuple[T]:
+    return (elem,)
+
+def main() -> None:
+    ((a, b),) = make_tuple((1, 2))
+    reveal_type(a) # E: Revealed type is 'builtins.int'
+    reveal_type(b) # E: Revealed type is 'builtins.int'
+[builtins fixtures/tuple.pyi]
+[out]

test-data/unit/pythoneval.test

@@ -1402,3 +1402,18 @@ o: object = p
 it2: Iterable[int] = p
 [out]
 _testCanConvertTypedDictToAnySuperclassOfMapping.py:11: error: Incompatible types in assignment (expression has type "Point", variable has type "Iterable[int]")
+
+[case testAsyncioGatherPreciseType]
+import asyncio
+from typing import Tuple
+
+async def get_location(arg: str) -> Tuple[str, str]:
+    return arg, arg
+
+async def main() -> None:
+    ((a_x, a_y),) = await asyncio.gather(get_location('start'))
+    reveal_type(a_x)
+    reveal_type(a_y)
+[out]
+_testAsyncioGatherPreciseType.py:9: error: Revealed type is 'builtins.str'
+_testAsyncioGatherPreciseType.py:10: error: Revealed type is 'builtins.str'