WIP: resolve review comment

Author: dhruvmanila

crates/red_knot_python_semantic/resources/mdtest/import/conventions.md

@@ -44,7 +44,7 @@ from math import Iterable
 reveal_type(Iterable)  # revealed: Unknown
 ```
 
-## Explicitly re-exported symbols in stub files
+## Re-exported symbols in stub files
 
 When a symbol is re-exported, imporing it should not raise an error. This tests both `import ...`
 and `from ... import ...` forms.
@@ -248,10 +248,10 @@ from c import Foo
 class Foo: ...
 ```
 
-## Implicit re-exports in `__init__.py`
+## Non-exports in `__init__.py`
 
 Red knot does not special case `__init__.py` files, so if a symbol is imported in `__init__.py`
-without an explicit re-export, it should raise an error.
+which is not re-exported, it should raise an error.
 
 TODO: When we support rule selection, the `implicit-reexport` rule should be disabled by default and
 this test case should be updated to explicitly enable it.
@@ -289,9 +289,9 @@ class Foo: ...
 ```py
 ```
 
-## Explicit re-exports in `__init__.py`
+## Re-exports in `__init__.py`
 
-But, if they're explicitly re-exported, it should not raise an error.
+But, if they're re-exported, it should not raise an error.
 
 TODO: When we support rule selection, the `implicit-reexport` rule should be disabled by default and
 this test case should be updated to explicitly enable it.
@@ -364,3 +364,65 @@ class Foo: ...
 
 ```pyi
 ```
+
+## Conditional re-export in stub file
+
+The following scenarios are when a re-export happens conditionally in a stub file.
+
+### Global import
+
+```toml
+log = 'salsa=warn,red_knot=debug'
+```
+
+```py
+from a import Foo
+```
+
+`a.pyi`:
+
+```pyi
+def coinflip() -> bool:
+    return True
+
+if coinflip():
+    class Foo: ...
+else:
+    from b import Foo
+
+```
+
+`b.pyi`:
+
+```pyi
+class Foo: ...
+```
+
+### Both branch is an import
+
+Here, both the branches of the condition are import statements where one of them re-exports while
+the other does not.
+
+```py
+# error: "Member `Foo` of module `a` is possibly unbound"
+from a import Foo
+
+reveal_type(Foo)  # revealed: Literal[Foo]
+```
+
+`a.pyi`:
+
+```pyi
+def coinflip() -> bool: ...
+
+if coinflip():
+    from b import Foo
+else:
+    from b import Foo as Foo
+```
+
+`b.pyi`:
+
+```pyi
+class Foo: ...
+```

crates/red_knot_python_semantic/src/symbol.rs

@@ -18,24 +18,68 @@ impl Boundness {
     }
 }
 
+/// Indicates whether a symbol is re-exported using the [import conventions].
+///
+/// [import conventions]: https://typing.readthedocs.io/en/latest/spec/distributing.html#import-conventions
 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
 pub(crate) enum ReExport {
-    Implicit,
-    Explicit,
-    None,
+    /// Symbol is either defined by an import statement and is re-exported, or it could be defined
+    /// by any other statement or expression.
+    ///
+    /// For example, in the following code:
+    /// ```py
+    /// import foo as foo
+    /// from foo import Bar as Bar
+    ///
+    /// baz = 1
+    /// ```
+    ///
+    /// All the symbols (`foo`, `Bar`, and `baz`) are re-exported.
+    Yes,
+
+    /// Symbol is defined by an import statement and is not re-exported.
+    ///
+    /// For example, in the following code:
+    /// ```py
+    /// import foo
+    /// from foo import Bar
+    /// ```
+    ///
+    /// Both `foo` (module) and `Bar` are not re-exported.
+    No,
+
+    /// Symbol is maybe re-exported.
+    ///
+    /// For example, in the following code:
+    /// ```py
+    /// if flag:
+    ///     import foo
+    /// else:
+    ///     import foo as foo
+    /// ```
+    ///
+    /// The `foo` symbol is maybe re-exported, depending on the value of `flag`.
+    ///
+    /// Or, in the following code:
+    /// ```py
+    /// import foo
+    ///
+    /// if flag:
+    ///     foo = 1
+    /// ```
+    ///
+    /// The `foo` symbol is maybe re-exported if the truthiness of `flag` is ambiguous.
+    Maybe,
 }
 
 impl ReExport {
-    pub(crate) const fn is_implicit(self) -> bool {
-        matches!(self, ReExport::Implicit)
-    }
-
     pub(crate) fn or(self, other: ReExport) -> ReExport {
-        match (self, other) {
-            (ReExport::Implicit, _) | (_, ReExport::Implicit) => ReExport::Implicit,
-            (ReExport::Explicit, ReExport::Explicit) => ReExport::Explicit,
-            (non_none, ReExport::None) | (ReExport::None, non_none) => non_none,
-        }
+        let result = match (self, other) {
+            (ReExport::Yes, ReExport::Yes) => ReExport::Yes,
+            (ReExport::No, ReExport::No) => ReExport::No,
+            _ => ReExport::Maybe,
+        };
+        result
     }
 }
 
@@ -139,53 +183,53 @@ mod tests {
         );
         assert_eq!(
             Symbol::Unbound
-                .or_fall_back_to(&db, &Symbol::Type(ty1, ReExport::None, PossiblyUnbound)),
-            Symbol::Type(ty1, ReExport::None, PossiblyUnbound)
+                .or_fall_back_to(&db, &Symbol::Type(ty1, ReExport::Yes, PossiblyUnbound)),
+            Symbol::Type(ty1, ReExport::Yes, PossiblyUnbound)
         );
         assert_eq!(
-            Symbol::Unbound.or_fall_back_to(&db, &Symbol::Type(ty1, ReExport::None, Bound)),
-            Symbol::Type(ty1, ReExport::None, Bound)
+            Symbol::Unbound.or_fall_back_to(&db, &Symbol::Type(ty1, ReExport::Yes, Bound)),
+            Symbol::Type(ty1, ReExport::Yes, Bound)
         );
 
         // Start from a possibly unbound symbol
         assert_eq!(
-            Symbol::Type(ty1, ReExport::None, PossiblyUnbound)
+            Symbol::Type(ty1, ReExport::Yes, PossiblyUnbound)
                 .or_fall_back_to(&db, &Symbol::Unbound),
-            Symbol::Type(ty1, ReExport::None, PossiblyUnbound)
+            Symbol::Type(ty1, ReExport::Yes, PossiblyUnbound)
         );
         assert_eq!(
-            Symbol::Type(ty1, ReExport::None, PossiblyUnbound)
-                .or_fall_back_to(&db, &Symbol::Type(ty2, ReExport::None, PossiblyUnbound)),
+            Symbol::Type(ty1, ReExport::Yes, PossiblyUnbound)
+                .or_fall_back_to(&db, &Symbol::Type(ty2, ReExport::Yes, PossiblyUnbound)),
             Symbol::Type(
                 UnionType::from_elements(&db, [ty2, ty1]),
-                ReExport::None,
+                ReExport::Yes,
                 PossiblyUnbound
             )
         );
         assert_eq!(
-            Symbol::Type(ty1, ReExport::None, PossiblyUnbound)
-                .or_fall_back_to(&db, &Symbol::Type(ty2, ReExport::None, Bound)),
+            Symbol::Type(ty1, ReExport::Yes, PossiblyUnbound)
+                .or_fall_back_to(&db, &Symbol::Type(ty2, ReExport::Yes, Bound)),
             Symbol::Type(
                 UnionType::from_elements(&db, [ty2, ty1]),
-                ReExport::None,
+                ReExport::Yes,
                 Bound
             )
         );
 
         // Start from a definitely bound symbol
         assert_eq!(
-            Symbol::Type(ty1, ReExport::None, Bound).or_fall_back_to(&db, &Symbol::Unbound),
-            Symbol::Type(ty1, ReExport::None, Bound)
+            Symbol::Type(ty1, ReExport::Yes, Bound).or_fall_back_to(&db, &Symbol::Unbound),
+            Symbol::Type(ty1, ReExport::Yes, Bound)
         );
         assert_eq!(
-            Symbol::Type(ty1, ReExport::None, Bound)
-                .or_fall_back_to(&db, &Symbol::Type(ty2, ReExport::None, PossiblyUnbound)),
-            Symbol::Type(ty1, ReExport::None, Bound)
+            Symbol::Type(ty1, ReExport::Yes, Bound)
+                .or_fall_back_to(&db, &Symbol::Type(ty2, ReExport::Yes, PossiblyUnbound)),
+            Symbol::Type(ty1, ReExport::Yes, Bound)
         );
         assert_eq!(
-            Symbol::Type(ty1, ReExport::None, Bound)
-                .or_fall_back_to(&db, &Symbol::Type(ty2, ReExport::None, Bound)),
-            Symbol::Type(ty1, ReExport::None, Bound)
+            Symbol::Type(ty1, ReExport::Yes, Bound)
+                .or_fall_back_to(&db, &Symbol::Type(ty2, ReExport::Yes, Bound)),
+            Symbol::Type(ty1, ReExport::Yes, Bound)
         );
     }
 }