Add check for exhaustive match statements

python · hauntsaninja · Jun 4, 2025 · May 23, 2025 · May 23, 2025 · May 23, 2025
commit 02796d944b0144535a7029e18947c49ca45c161b
diff --git a/mypy/checker.py b/mypy/checker.py
@@ -5452,6 +5452,7 @@ def visit_match_stmt(self, s: MatchStmt) -> None:
            inferred_types = self.infer_variable_types_from_type_maps(type_maps)

            # The second pass narrows down the types and type checks bodies.
+            unmatched_types: TypeMap = None
            for p, g, b in zip(s.patterns, s.guards, s.bodies):
                current_subject_type = self.expr_checker.narrow_type_from_binder(
                    named_subject, subject_type
@@ -5508,6 +5509,12 @@ def visit_match_stmt(self, s: MatchStmt) -> None:
                    else:
                        self.accept(b)
                self.push_type_map(else_map, from_assignment=False)
+                unmatched_types = else_map
+
+            if unmatched_types is not None:
+                # for expr, typ in unmatched_types.items():
+                for typ in set(unmatched_types.values()):
+                    self.msg.match_statement_unexhaustive_match(typ, s)

            # This is needed due to a quirk in frame_context. Without it types will stay narrowed
            # after the match.

diff --git a/mypy/messages.py b/mypy/messages.py
@@ -2486,6 +2486,14 @@ def type_parameters_should_be_declared(self, undeclared: list[str], context: Con
            code=codes.VALID_TYPE,
        )

+    def match_statement_unexhaustive_match(self, typ: Type, context: Context) -> None:
+        type_str = format_type(typ, self.options)
+        msg = (
+            f"Cases within match statement do not exhaustively handle all values: {type_str}."
+            " If not intended to handle all cases, use `case _: pass`"
+        )
+        self.fail(msg, context)
+

 def quote_type_string(type_string: str) -> str:
    """Quotes a type representation for use in messages."""

diff --git a/test-data/unit/check-match-exhaustive.test b/test-data/unit/check-match-exhaustive.test
@@ -0,0 +1,136 @@
+[case testExhaustiveMatchNoFlag]
+# flags: --python-version 3.12
+a: int = 5
+match a:
+    case 1:
+        pass
+    case _:
+        pass
+
+b: str = "hello"
+match b:
+    case "bye":
+        pass
+    case _:
+        pass
+
+[case testNonExhaustiveMatchNoFlag]
+# flags: --python-version 3.12
+a: int = 5
+match a:
+    case 1:
+        pass
+
+b: str = "hello"
+match b:
+    case "bye":
+        pass
+
+
+[case testExhaustiveMatchWithFlag]
+# flags: --python-version 3.12 --only-allow-exhaustive-match-statements
+a: int = 5
+match a:
+    case 1:
+        pass
+    case _:
+        pass
+
+b: str = "hello"
+match b:
+    case "bye":
+        pass
+    case _:
+        pass
+
+[case testNonExhaustiveMatchWithFlag]
+# flags: --python-version 3.12 --only-allow-exhaustive-match-statements
+a: int = 5
+match a: # E: Cases within match statement do not exhaustively handle all values: "int". If not intended to handle all cases, use `case _: pass`
+    case 1:
+        pass
+
+b: str = "hello"
+match b: # E: Cases within match statement do not exhaustively handle all values: "str". If not intended to handle all cases, use `case _: pass`
+    case "bye":
+        pass
+
+[case testEnumNonExhaustiveWithFlag]
+# flags: --python-version 3.12 --only-allow-exhaustive-match-statements
+
+import enum
+
+class Color(enum.Enum):
+    RED = 1
+    BLUE = 2
+    GREEN = 3
+
+val: Color = Color.RED
+
+match val: # E: Cases within match statement do not exhaustively handle all values: "Literal[Color.GREEN]". If not intended to handle all cases, use `case _: pass`
+    case Color.RED:
+        a = "red"
+    case Color.BLUE:
+        a= "blue"
+
+[builtins fixtures/enum.pyi]
+
+
+[case testEnumExhaustiveWithFlag]
+# flags: --python-version 3.12 --only-allow-exhaustive-match-statements
+
+import enum
+
+class Color(enum.Enum):
+    RED = 1
+    BLUE = 2
+
+val: Color = Color.RED
+
+match val:
+    case Color.RED:
+        a = "red"
+    case Color.BLUE:
+        a= "blue"
+
+[builtins fixtures/enum.pyi]
+
+[case testEnumMultipleMissingMatchesWithFlag]
+# flags: --python-version 3.12 --only-allow-exhaustive-match-statements
+
+import enum
+
+class Color(enum.Enum):
+    RED = 1
+    BLUE = 2
+    GREEN = 3
+
+val: Color = Color.RED
+
+match val: # E: Cases within match statement do not exhaustively handle all values: "Literal[Color.BLUE, Color.GREEN]". If not intended to handle all cases, use `case _: pass`
+    case Color.RED:
+        a = "red"
+
+
+[builtins fixtures/enum.pyi]
+
+[case testEnumFallbackWithFlag]
+# flags: --python-version 3.12 --only-allow-exhaustive-match-statements
+
+import enum
+
+class Color(enum.Enum):
+    RED = 1
+    BLUE = 2
+    GREEN = 3
+
+val: Color = Color.RED
+
+match val:
+    case Color.RED:
+        a = "red"
+    case _:
+        a = "other"
+
+
+[builtins fixtures/enum.pyi]
-Original file line number
+Diff line change
@@ -5452,6 +5452,7 @@ def visit_match_stmt(self, s: MatchStmt) -> None:
                 inferred_types = self.infer_variable_types_from_type_maps(type_maps)
                 # The second pass narrows down the types and type checks bodies.
+                unmatched_types: TypeMap = None
                 for p, g, b in zip(s.patterns, s.guards, s.bodies):
                     current_subject_type = self.expr_checker.narrow_type_from_binder(
                         named_subject, subject_type
@@ -5508,6 +5509,12 @@ def visit_match_stmt(self, s: MatchStmt) -> None:
                         else:
                             self.accept(b)
                     self.push_type_map(else_map, from_assignment=False)
+                    unmatched_types = else_map
             Copy link

  
      
    
  

  
      

  
    Collaborator


      

  

  
    
      

      
            sterliakov
  

      

      

      


        May 28, 2025


      
    

  


        
      
  
  
  
    

    There was a problem hiding this comment.


  

 
  
    

    Choose a reason for hiding this comment

    
      The reason will be displayed to describe this comment to others. Learn more.
    

    
      
      


  


  
    
      Does it work as intended when typemaps contain more than immediate targets?
For example, what happens in the following fork of an existing test testMatchNarrowingUnionTypedDictViaIndex with this flag enabled? If I remember the surrounding logic correctly, there will be two typemap entries - for d['tag'] and for d, so two diagnostics?
from typing import Literal, TypedDict

class A(TypedDict):
    tag: Literal["a"]
    name: str

class B(TypedDict):
    tag: Literal["b"]
    num: int

d: A | B
match d["tag"]:
    case "a":
        reveal_type(d)  # N: Revealed type is "TypedDict('__main__.A', {'tag': Literal['a'], 'name': builtins.str})"
        reveal_type(d["name"])  # N: Revealed type is "builtins.str"
    
  
  


    

        
      
  
  
    
  
  
  
    
    Sorry, something went wrong.
  

  
    
  
    
      

              Uh oh!

              
There was an error while loading. Please reload this page.


  
  


          
      
  
    
    
      
        
            
    All reactions
  


          
          
        
      
    

    



    
        
  
    
        
    
  


      
          
  
      
            Copy link

  
      
    
  

  
      

  
    Contributor


      

  Author


  

  
    
      

      
            Don-Burns
  

      

      

      


        May 28, 2025


      
  •

  
    
      
        
          edited
          
        
        
      
    
    
      
  
        
      Loading


  
    
  
    
      

              Uh oh!

              
There was an error while loading. Please reload this page.


  
  
    
  


    

  


        
      
  
  
  
    

    There was a problem hiding this comment.


  

 
  
    

    Choose a reason for hiding this comment

    
      The reason will be displayed to describe this comment to others. Learn more.
    

    
      
      


  


  
    
      I would say that yes, it is behaving as I originally intended with 2 diagnostics. Added a test testExhaustiveMatchNarrowingUnionTypedDictViaIndex for the use case you have above.

d219871
My thinking of having multiple diagnostics is it might be a bit easier to read/understand in the case of longer unions, but I don't have a very strong opinion here either way
    
  
  


    

        
      
  
  
    
  
  
  
    
    Sorry, something went wrong.
  

  
    
  
    
      

              Uh oh!

              
There was an error while loading. Please reload this page.


  
  


          
      
  
    
    
      
        
            
    All reactions
+                if unmatched_types is not None:
+                    # for expr, typ in unmatched_types.items():
+                    for typ in set(unmatched_types.values()):
+                        self.msg.match_statement_unexhaustive_match(typ, s)
                 # This is needed due to a quirk in frame_context. Without it types will stay narrowed
                 # after the match.
-          Expand Down