Fix: Handle all expression types in contains_assignment_expr for walrus operator detection

- Add missing imports: ConditionalExpr, GeneratorExpr, ListComprehension, SetComprehension, DictionaryComprehension, SliceExpr
- Handle ConditionalExpr (ternary operator) to check cond, if_expr, and else_expr
- Handle SliceExpr to check begin_index, end_index, and stride
- Handle GeneratorExpr and comprehensions (ListComprehension, SetComprehension, DictionaryComprehension)
- Ensures comprehensive detection of assignment expressions (walrus operators) in all nested expression contexts
- Fixes CI failures related to incomplete expression type handling

Author: Kunal Sali

mypy/checker.py

@@ -85,11 +85,13 @@
     CallExpr,
     ClassDef,
     ComparisonExpr,
+    ConditionalExpr,
     Context,
     ContinueStmt,
     Decorator,
     DelStmt,
     DictExpr,
+    DictionaryComprehension,
     EllipsisExpr,
     Expression,
     ExpressionStmt,
@@ -98,6 +100,7 @@
     FuncBase,
     FuncDef,
     FuncItem,
+    GeneratorExpr,
     GlobalDecl,
     IfStmt,
     Import,
@@ -107,6 +110,7 @@
     IndexExpr,
     IntExpr,
     LambdaExpr,
+    ListComprehension,
     ListExpr,
     Lvalue,
     MatchStmt,
@@ -124,7 +128,9 @@
     RaiseStmt,
     RefExpr,
     ReturnStmt,
+    SetComprehension,
     SetExpr,
+    SliceExpr,
     StarExpr,
     Statement,
     StrExpr,
@@ -5132,11 +5138,54 @@ def contains_assignment_expr(self, expr: Expression) -> bool:
             if expr.expr is not None:
                 return self.contains_assignment_expr(expr.expr)
             return False
-
-        # Conditional expressions (ternary operator)
-        # Note: ConditionalExpr might not be in imports, but if it exists, handle it
-        # For now, we'll skip it if it's not imported
-
+        
+        # Conditional expressions (ternary operator: x if cond else y)
+        if isinstance(expr, ConditionalExpr):
+            return (
+                self.contains_assignment_expr(expr.cond)
+                or self.contains_assignment_expr(expr.if_expr)
+                or self.contains_assignment_expr(expr.else_expr)
+            )
+        
+        # Slice expressions (x:y:z)
+        if isinstance(expr, SliceExpr):
+            return (
+                (expr.begin_index is not None and self.contains_assignment_expr(expr.begin_index))
+                or (expr.end_index is not None and self.contains_assignment_expr(expr.end_index))
+                or (expr.stride is not None and self.contains_assignment_expr(expr.stride))
+            )
+        
+        # Generator expressions and comprehensions
+        if isinstance(expr, GeneratorExpr):
+            if self.contains_assignment_expr(expr.left_expr):
+                return True
+            for seq in expr.sequences:
+                if self.contains_assignment_expr(seq):
+                    return True
+            for condlist in expr.condlists:
+                for cond in condlist:
+                    if self.contains_assignment_expr(cond):
+                        return True
+            return False
+        
+        if isinstance(expr, ListComprehension):
+            return self.contains_assignment_expr(expr.generator)
+        
+        if isinstance(expr, SetComprehension):
+            return self.contains_assignment_expr(expr.generator)
+        
+        if isinstance(expr, DictionaryComprehension):
+            if self.contains_assignment_expr(expr.key) or self.contains_assignment_expr(expr.value):
+                return True
+            for seq in expr.sequences:
+                if self.contains_assignment_expr(seq):
+                    return True
+            for condlist in expr.condlists:
+                for cond in condlist:
+                    if self.contains_assignment_expr(cond):
+                        return True
+            return False
+        
         # All other expression types (NameExpr, IntExpr, StrExpr, etc.) don't contain nested expressions
         return False