Minor doc updates

Author: sharkdp

crates/red_knot_python_semantic/src/semantic_index/use_def.rs

@@ -690,9 +690,9 @@ impl<'db> UseDefMapBuilder<'db> {
 ///    x = 2
 /// ```
 ///
-/// Here, `x` is definitely bound if `test2` is always true OR if `test1` is always true. `x` is
-/// definitely unbound if `test1` is always false AND `test2` is always false. And `x` is possibly
-/// unbound in all other cases.
+/// Here, `x` is definitely bound if `test1` is always true OR if `test2` is always true. `x` is
+/// definitely unbound if `test1` is always false AND `test2` is always false. `x` is possibly
+/// unbound in all other cases. This logic is handled in [`StaticTruthiness::flow_merge`].
 ///
 /// Finally, we also need to consider that a symbol could be definitely bound, even if we can not
 /// statically infer the truthiness of a test condition. On such example is:
@@ -714,7 +714,7 @@ where
     C: Iterator<Item = BranchingConditionsIterator<'map, 'db>>,
 {
     let result = conditions_per_binding.fold(StaticTruthiness::no_bindings(), |r, conditions| {
-        r.merge(&StaticTruthiness::analyze(db, conditions))
+        r.flow_merge(&StaticTruthiness::analyze(db, conditions))
     });
 
     let definitely_unbound = result.any_always_false;

crates/red_knot_python_semantic/src/types/static_truthiness.rs

@@ -107,10 +107,10 @@ impl StaticTruthiness {
     /// of the fields. The reason for this is that we want to draw conclusions like "this symbol can
     /// not be bound because one of the branching conditions is always false". We can only draw this
     /// conclusion if this is true in both control-flow paths. Similarly, we want to infer that the
-    /// binding of a symbol is unconditionally visible, if all branching conditions are known to be
-    /// statically true. It is enough if this is the case for *any* of the control-flow paths. Other
-    /// control flow paths will not be taken if this is the case.
-    pub(crate) fn merge(self, other: &Self) -> Self {
+    /// binding of a symbol is unconditionally visible if all branching conditions are known to be
+    /// statically true. It is enough if this is the case for either of the two control-flow paths.
+    /// The other paths can not be taken if this is the case.
+    pub(crate) fn flow_merge(self, other: &Self) -> Self {
         Self {
             any_always_false: self.any_always_false && other.any_always_false,
             all_always_true: self.all_always_true || other.all_always_true,