Merge remote-tracking branch 'upstream/master' into bugfix/st-synthet…

…ic-named-expr-in-match
python · sterliakov · Jan 11, 2025 · Jan 13, 2025 · Jan 13, 2025 · Jan 20, 2025
commit 6e09fd03b8b4415d8df9cdd39d4ea3b817c95164
diff --git a/mypy/checker.py b/mypy/checker.py
@@ -5533,7 +5533,7 @@ def visit_continue_stmt(self, s: ContinueStmt) -> None:
         return
 
     def visit_match_stmt(self, s: MatchStmt) -> None:
-        named_subject = self._make_named_statement_for_match(s.subject)
+        named_subject = self._make_named_statement_for_match(s)
         with self.binder.frame_context(can_skip=False, fall_through=0):
             subject_type = get_proper_type(self.expr_checker.accept(s.subject))
 
@@ -5612,8 +5612,9 @@ def visit_match_stmt(self, s: MatchStmt) -> None:
             with self.binder.frame_context(can_skip=False, fall_through=2):
                 pass
 
-    def _make_named_statement_for_match(self, subject: Expression) -> Expression:
+    def _make_named_statement_for_match(self, s: MatchStmt) -> Expression:
         """Construct a fake NameExpr for inference if a match clause is complex."""
+        subject = s.subject
         expressions_to_preserve = (
             # Already named - we should infer type of it as given
             NameExpr,
@@ -5634,6 +5635,8 @@ def _make_named_statement_for_match(self, subject: Expression) -> Expression:
         )
         if isinstance(subject, expressions_to_preserve):
             return subject
+        elif s.subject_dummy is not None:
+            return s.subject_dummy
         else:
             # Create a dummy subject expression to handle cases where a match statement's subject
             # is not a literal value. This lets us correctly narrow types and check exhaustivity
@@ -5642,6 +5645,7 @@ def _make_named_statement_for_match(self, subject: Expression) -> Expression:
             v = Var(name)
             named_subject = NameExpr(name)
             named_subject.node = v
+            s.subject_dummy = named_subject
             return named_subject
 
     def _get_recursive_sub_patterns_map(

diff --git a/test-data/unit/check-python310.test b/test-data/unit/check-python310.test
@@ -2668,3 +2668,56 @@ match 0:
         i  # E: Statement is unreachable
     case other:
         other  # E: Statement is unreachable
+
+[case testMatchNamedTupleSequence]
+from typing import Any, NamedTuple
+
+class T(NamedTuple):
+    t: list[Any]
+
+class K(NamedTuple):
+    k: int
+
+def f(t: T) -> None:
+    match t:
+        case T([K() as k]):
+            reveal_type(k)  # N: Revealed type is "Tuple[builtins.int, fallback=__main__.K]"
+[builtins fixtures/tuple.pyi]
+
+[case testNewRedefineMatchBasics]
+# flags: --allow-redefinition-new --local-partial-types
+
+def f1(x: int | str | list[bytes]) -> None:
+    match x:
+        case int():
+            reveal_type(x) # N: Revealed type is "builtins.int"
+        case str(y):
+            reveal_type(y) # N: Revealed type is "builtins.str"
+        case [y]:
+            reveal_type(y) # N: Revealed type is "builtins.bytes"
+    reveal_type(y) # N: Revealed type is "Union[builtins.str, builtins.bytes]"
+
+[case testNewRedefineLoopWithMatch]
+# flags: --allow-redefinition-new --local-partial-types
+
+def f1() -> None:
+    while True:
+        x = object()
+        match x:
+            case str(y):
+                pass
+            case int():
+                pass
+        if int():
+            continue
+
+def f2() -> None:
+    for x in [""]:
+        match str():
+            case "a":
+                y = ""
+            case "b":
+                y = 1
+                return
+    reveal_type(y) # N: Revealed type is "builtins.str"
+[builtins fixtures/list.pyi]