Fixed bug in type narrowing logic for sequence pattern matching. This addresses #11056. (#11085)

Author: erictraut

packages/pyright-internal/src/analyzer/patternMatching.ts

@@ -1414,23 +1414,28 @@ function getSequencePatternInfo(
                         { type: UnknownType.create(), isUnbounded: true },
                     ];
 
-                    const tupleIndeterminateIndex = typeArgs.findIndex(
+                    let tupleIndeterminateIndex = typeArgs.findIndex(
                         (t) => t.isUnbounded || isUnpackedTypeVarTuple(t.type) || isUnpackedTypeVar(t.type)
                     );
 
                     let tupleDeterminateEntryCount = typeArgs.length;
 
                     // If the tuple contains an indeterminate entry, expand or remove that
                     // entry to match the length of the pattern if possible.
+                    let expandedIndeterminate = false;
                     if (tupleIndeterminateIndex >= 0) {
                         tupleDeterminateEntryCount--;
 
                         while (typeArgs.length < patternEntryCount) {
                             typeArgs.splice(tupleIndeterminateIndex, 0, typeArgs[tupleIndeterminateIndex]);
+                            tupleDeterminateEntryCount++;
+                            tupleIndeterminateIndex++;
+                            expandedIndeterminate = true;
                         }
 
                         if (typeArgs.length > patternEntryCount && patternStarEntryIndex === undefined) {
                             typeArgs.splice(tupleIndeterminateIndex, 1);
+                            tupleIndeterminateIndex = -1;
                         }
                     }
 
@@ -1449,6 +1454,20 @@ function getSequencePatternInfo(
                                 (t) => t.isUnbounded || isUnpackedTypeVarTuple(t.type) || isUnpackedTypeVar(t.type)
                             ),
                         });
+
+                        tupleDeterminateEntryCount -= entriesToCombine;
+                        if (!typeArgs[patternStarEntryIndex].isUnbounded) {
+                            tupleDeterminateEntryCount++;
+                        }
+
+                        // If the collapsed range included the tupleIndeterminateIndex, adjust
+                        // it to reflect the new collapsed entry.
+                        if (
+                            tupleIndeterminateIndex >= patternStarEntryIndex &&
+                            tupleIndeterminateIndex < patternStarEntryIndex + entriesToCombine
+                        ) {
+                            tupleIndeterminateIndex = patternStarEntryIndex;
+                        }
                     }
 
                     if (typeArgs.length === patternEntryCount) {
@@ -1459,6 +1478,7 @@ function getSequencePatternInfo(
                         // indeterminate-length entry that aligns to the star entry, we can
                         // assume it will always match.
                         if (
+                            !expandedIndeterminate &&
                             patternStarEntryIndex !== undefined &&
                             tupleIndeterminateIndex >= 0 &&
                             pattern.d.entries.length - 1 === tupleDeterminateEntryCount &&

packages/pyright-internal/src/tests/samples/matchSequence1.py

@@ -627,6 +627,38 @@ def test_unbounded_tuple_6(subj: tuple[str, ...]):
             reveal_type(r, expected_text="tuple[str, ...]")
 
 
+def test_unbound_tuple_7(subj: tuple[str, Unpack[tuple[object, ...]], int]):
+    match subj:
+        case (*args,):
+            reveal_type(args, expected_text="list[str | object | int]")
+        case a:
+            reveal_type(a, expected_text="Never")
+
+    match subj:
+        case (*args, last):
+            reveal_type(args, expected_text="list[str | object]")
+            reveal_type(last, expected_text="int")
+        case a:
+            reveal_type(a, expected_text="Never")
+
+    match subj:
+        case (first, *args, last):
+            reveal_type(first, expected_text="str")
+            reveal_type(args, expected_text="list[object]")
+            reveal_type(last, expected_text="int")
+        case a:
+            reveal_type(a, expected_text="Never")
+
+    match subj:
+        case (first, second, *args, last):
+            reveal_type(first, expected_text="str")
+            reveal_type(second, expected_text="object")
+            reveal_type(args, expected_text="list[object]")
+            reveal_type(last, expected_text="int")
+        case a:
+            reveal_type(a, expected_text="tuple[str, *tuple[object, ...], int]")
+
+
 def test_variadic_tuple(subj: tuple[int, Unpack[Ts]]) -> tuple[Unpack[Ts]]:
     match subj:
         case _, *rest: