Fixed translation of a heterogenous tuple into an iterator. The resulting iterator needs to have a type argument created from a union of the heterogeneous tuple entries.

server/src/analyzer/typeUtils.ts

@@ -720,7 +720,21 @@ export function setTypeArgumentsRecursive(destType: Type, srcType: Type,
 // _T1 with str and _T2 with int.
 export function buildTypeVarMapFromSpecializedClass(classType: ClassType): TypeVarMap {
     const typeParameters = ClassType.getTypeParameters(classType);
-    return buildTypeVarMap(typeParameters, classType.typeArguments);
+    let typeArguments = classType.typeArguments;
+
+    // Handle the special case where the source is a Tuple with heterogenous
+    // type arguments. In this case, we'll create a union out of the heterogeneous
+    // types.
+    if (ClassType.isBuiltIn(classType, 'Tuple') && classType.typeArguments) {
+        if (classType.typeArguments.length > 1) {
+            const lastTypeArg = classType.typeArguments[classType.typeArguments.length - 1];
+            if (!isEllipsisType(lastTypeArg)) {
+                typeArguments = [combineTypes(classType.typeArguments)];
+            }
+        }
+    }
+
+    return buildTypeVarMap(typeParameters, typeArguments);
 }
 
 export function buildTypeVarMap(typeParameters: TypeVarType[], typeArgs: Type[] | undefined): TypeVarMap {

server/src/tests/checker.test.ts

@@ -430,6 +430,12 @@ test('Tuples3', () => {
     validateResults(analysisResults, 2);
 });
 
+test('Tuples4', () => {
+    const analysisResults = TestUtils.typeAnalyzeSampleFiles(['tuples4.py']);
+
+    validateResults(analysisResults, 0);
+});
+
 test('NamedTuples1', () => {
     const analysisResults = TestUtils.typeAnalyzeSampleFiles(['namedTuples1.py']);
 

server/src/tests/samples/tuples4.py

@@ -0,0 +1,17 @@
+# This sample tests the translation of a heterogenous tuple
+# into an Interable.
+
+from typing import Iterable, Iterator, List, Tuple, TypeVar, Union
+
+_T = TypeVar('_T')
+def foo(x: Iterable[_T]):
+    return x
+
+def bar(x: Iterable[Union[int, str]]): pass
+
+my_tuple = (3, 'hello')
+
+# The type of my_iterable should be Iterable[Union[int, str]].
+my_iterable = foo(my_tuple)
+bar(my_iterable)
+