Track node context

Author: cdce8p

mypy/checkpattern.py

@@ -14,7 +14,7 @@
 from mypy.maptype import map_instance_to_supertype
 from mypy.meet import narrow_declared_type
 from mypy.messages import MessageBuilder
-from mypy.nodes import ARG_POS, Context, Expression, NameExpr, TypeAlias, Var
+from mypy.nodes import ARG_POS, Context, Expression, NameExpr, Node, TypeAlias, Var
 from mypy.options import Options
 from mypy.patterns import (
     AsPattern,
@@ -104,6 +104,8 @@ class PatternChecker(PatternVisitor[PatternType]):
     subject_type: Type
     # Type of the subject to check the (sub)pattern against
     type_context: list[Type]
+    # Pattern node currently being processed
+    node_context: list[Node]
     # Types that match against self instead of their __match_args__ if used as a class pattern
     # Filled in from self_match_type_names
     self_match_types: list[Type]
@@ -121,6 +123,7 @@ def __init__(
         self.plugin = plugin
 
         self.type_context = []
+        self.node_context = []
         self.self_match_types = self.generate_types_from_names(self_match_type_names)
         self.non_sequence_match_types = self.generate_types_from_names(
             non_sequence_match_type_names
@@ -129,8 +132,10 @@ def __init__(
 
     def accept(self, o: Pattern, type_context: Type) -> PatternType:
         self.type_context.append(type_context)
+        self.node_context.append(o)
         result = o.accept(self)
         self.type_context.pop()
+        self.node_context.pop()
 
         return result
 
@@ -140,7 +145,12 @@ def visit_as_pattern(self, o: AsPattern) -> PatternType:
             pattern_type = self.accept(o.pattern, current_type)
             typ, rest_type, type_map = pattern_type
         else:
-            typ, rest_type, type_map = current_type, UninhabitedType(), {}
+            typ, type_map = current_type, {}
+            if len(self.node_context) >= 2 and isinstance(self.node_context[-2], SequencePattern):
+                # Don't narrow rest type to Never if parent node is a sequence pattern
+                rest_type = current_type
+            else:
+                rest_type = UninhabitedType()
 
         if not is_uninhabited(typ) and o.name is not None:
             typ, _ = self.chk.conditional_types_with_intersection(
@@ -315,21 +325,7 @@ def visit_sequence_pattern(self, o: SequencePattern) -> PatternType:
                     )
                 )
                 narrowed_inner_types.append(narrowed_inner_type)
-                narrowed_ptype = get_proper_type(narrowed_inner_type)
-                if (
-                    is_uninhabited(inner_rest_type)
-                    and isinstance(narrowed_ptype, Instance)
-                    and (
-                        narrowed_ptype.type.fullname == "builtins.dict"
-                        or narrowed_ptype.type.fullname == "builtins.list"
-                    )
-                ):
-                    # Can't narrow rest type to uninhabited
-                    # if narrowed_type is dict or list.
-                    # Those can be matched by Mapping or Sequence patterns.
-                    inner_rest_types.append(narrowed_inner_type)
-                else:
-                    inner_rest_types.append(inner_rest_type)
+                inner_rest_types.append(inner_rest_type)
             if all(not is_uninhabited(typ) for typ in narrowed_inner_types):
                 new_type = TupleType(narrowed_inner_types, current_type.partial_fallback)
             else:

test-data/unit/check-python310.test

@@ -1742,13 +1742,33 @@ match (m7, m7):
     case (_, {"a": "2"}):
         reveal_type(m7)  # N: Revealed type is "builtins.dict[builtins.str, builtins.str]"
 
+match (m7, m7):
+    case (dict(), _):
+        reveal_type(m7)  # N: Revealed type is "builtins.dict[builtins.str, builtins.str]"
+    case (_, dict()):
+        reveal_type(m7)  # E: Statement is unreachable
+    case (_, _):
+        reveal_type(m7)  # E: Statement is unreachable
+
+match (m7, 4):
+    case ({"a": "1"}, _):
+        reveal_type(m7)  # N: Revealed type is "builtins.dict[builtins.str, builtins.str]"
+    case r7:
+        reveal_type(r7)  # N: Revealed type is "tuple[builtins.dict[builtins.str, builtins.str], Literal[4]?]"
+
 m8: list[int]
 
 match (m8, m8):
     case ([1], _):
         reveal_type(m8)  # N: Revealed type is "builtins.list[builtins.int]"
     case (_, [2]):
         reveal_type(m8)  # N: Revealed type is "builtins.list[builtins.int]"
+
+match (m8, m8):
+    case (list(), _):
+        reveal_type(m8)  # N: Revealed type is "builtins.list[builtins.int]"
+    case (_, [2]):
+        reveal_type(m8)  # E: Statement is unreachable
 [builtins fixtures/dict.pyi]
 
 [case testMatchEnumSingleChoice]