[red-knot] Fix merged type after if-else without explicit else branch

crates/red_knot_python_semantic/resources/mdtest/narrow/post_if_statement.md

@@ -0,0 +1,65 @@
+# Consolidating narrowed types after if statement
+
+## After if-else statements, narrowing has no-effect if variable is not mutated
+
+```py
+def optional_int() -> int | None: ...
+
+x = optional_int()
+
+if x is None:
+    pass
+else:
+    pass
+
+reveal_type(x)  # revealed: int | None
+```
+
+## After if-else statements, narrowing has an effect if variable is mutated
+
+```py
+def optional_int() -> int | None: ...
+
+x = optional_int()
+y = optional_int()
+
+if x is None:
+    x = 10
+else:
+    pass
+
+reveal_type(x)  # revealed: int
+```
+
+## if statement without explicit else branch, act similar to empty else branch
+
+```py
+def optional_int() -> int | None: ...
+
+x = optional_int()
+y = optional_int()
+
+if x is None:
+    x = 0
+
+if y is None:
+    pass
+
+reveal_type(x)  # revealed: int
+reveal_type(y)  # revealed: int | None
+```
+
+## if-elif without explicit else branch, act similar to empty else branch
+
+```py
+def optional_int() -> int | None: ...
+
+x = optional_int()
+
+if x is None:
+    x = 0
+elif x > 50:
+    x = 50
+
+reveal_type(x)  # revealed: int
+```

crates/red_knot_python_semantic/src/semantic_index/builder.rs

@@ -785,17 +785,21 @@ where
                     }
                     self.visit_body(&clause.body);
                 }
-                for post_clause_state in post_clauses {
-                    self.flow_merge(post_clause_state);
-                }
                 let has_else = node
                     .elif_else_clauses
                     .last()
                     .is_some_and(|clause| clause.test.is_none());
                 if !has_else {
-                    // if there's no else clause, then it's possible we took none of the branches,
-                    // and the pre_if state can reach here
-                    self.flow_merge(pre_if);
+                    // if there's no else clause, we should act as if we had an empty else clause,
+                    // by again following the same logic as above for elif/else clauses.
+                    post_clauses.push(self.flow_snapshot());
+                    self.flow_restore(pre_if);
+                    for constraint in &constraints {
+                        self.record_negated_constraint(*constraint);
+                    }
+                }
+                for post_clause_state in post_clauses {
+                    self.flow_merge(post_clause_state);
                 }
             }
             ast::Stmt::While(ast::StmtWhile {