red-knot: support narrowing for bool(E)

crates/red_knot_python_semantic/resources/mdtest/narrow/conditionals/boolean.md

@@ -280,3 +280,36 @@ if x is None:
 if y is not x:
     reveal_type(y)  # revealed: str | None
 ```
+
+## `bool(..)` builtin containing expression narrows for expression
+
+```py
+def flag() -> bool: ...
+
+x = 1 if flag() else None
+
+# valid invocation, positive
+reveal_type(x)  # revealed: Literal[1] | None
+if bool(x is not None):
+    reveal_type(x)  # revealed: Literal[1]
+
+# valid invocation, negative
+reveal_type(x)  # revealed: Literal[1] | None
+if not bool(x is not None):
+    reveal_type(x)  # revealed: None
+
+# no args/narrowing
+reveal_type(x)  # revealed: Literal[1] | None
+if bool():
+    reveal_type(x)  # revealed: Literal[1] | None
+
+# invalid invocation, too many positional args
+reveal_type(x)  # revealed: Literal[1] | None
+if bool(x is not None, 5):
+    reveal_type(x)  # revealed: Literal[1] | None
+
+# invalid invocation, too many kwargs
+reveal_type(x)  # revealed: Literal[1] | None
+if bool(x is not None, y=5):
+    reveal_type(x)  # revealed: Literal[1] | None
+```

crates/red_knot_python_semantic/src/types/narrow.rs

@@ -385,10 +385,11 @@ impl<'db> NarrowingConstraintsBuilder<'db> {
         let scope = self.scope();
         let inference = infer_expression_types(self.db, expression);
 
+        let expr_ty = inference.expression_ty(expr_call.func.scoped_expression_id(self.db, scope));
+
         // TODO: add support for PEP 604 union types on the right hand side of `isinstance`
         // and `issubclass`, for example `isinstance(x, str | (int | float))`.
-        match inference
-            .expression_ty(expr_call.func.scoped_expression_id(self.db, scope))
+        match expr_ty
             .into_function_literal()
             .and_then(|f| f.known(self.db))
             .and_then(KnownFunction::constraint_function)
@@ -426,7 +427,24 @@ impl<'db> NarrowingConstraintsBuilder<'db> {
                     None
                 }
             }
-            _ => None,
+            _ => {
+                let is_valid_bool_invocation =
+                    expr_call.arguments.args.len() == 1 && expr_call.arguments.keywords.is_empty();
+
+                if is_valid_bool_invocation
+                    && expr_ty
+                        .into_class_literal()
+                        .is_some_and(|lit| lit.class.is_known(self.db, KnownClass::Bool))
+                {
+                    self.evaluate_expression_node_constraint(
+                        &expr_call.arguments.args[0],
+                        expression,
+                        is_positive,
+                    )
+                } else {
+                    None
+                }
+            }
         }
     }