add more edge cases

Author: AlexWaygood

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

@@ -1,5 +1,7 @@
 # Wildcard (`*`) imports
 
+See the [Python language reference for import statements].
+
 ## Basic functionality
 
 ### A simple `*` import
@@ -130,6 +132,130 @@ from c import X  # error: [unresolved-import]
 from c import Y  # error: [unresolved-import]
 ```
 
+### Global-scope symbols defined using walrus expressions
+
+`a.py`:
+
+```py
+X = (Y := 3) + 4
+```
+
+`b.py`:
+
+```py
+# TODO: should not error
+from a import *  # error: [unresolved-import]
+
+# TODO should not error, should reveal `Literal[7] | Unknown`
+# error: [unresolved-reference]
+reveal_type(X)  # revealed: Unknown
+# TODO should not error, should reveal `Literal[3] | Unknown`
+# error: [unresolved-reference]
+reveal_type(Y)  # revealed: Unknown
+```
+
+### Global-scope names starting with underscores
+
+Global-scope names starting with underscores are not imported from a `*` import (unless the module
+has `__all__` and they are included in `__all__`):
+
+`a.py`:
+
+```py
+_private: bool = False
+__protected: bool = False
+__dunder__: bool = False
+___thunder___: bool = False
+
+Y: bool = True
+```
+
+`b.py`:
+
+```py
+# TODO: should not error
+from a import *  # error: [unresolved-import]
+
+# These errors are correct:
+#
+# error: [unresolved-reference]
+reveal_type(_private)  # revealed: Unknown
+# error: [unresolved-reference]
+reveal_type(__protected)  # revealed: Unknown
+# error: [unresolved-reference]
+reveal_type(__dunder__)  # revealed: Unknown
+# error: [unresolved-reference]
+reveal_type(___thunder___)  # revealed: Unknown
+
+# TODO: this error is incorrect (should reveal `bool`):
+#
+# error: [unresolved-reference]
+reveal_type(Y)  # revealed: Unknown
+```
+
+### All public symbols are considered re-exported from `.py` files
+
+For `.py` files, we should consider all public symbols in the global namespace exported by that
+module when considering which symbols are made available by a `*` import. Here, `b.py` does not use
+the explicit `from a import X as X` syntax to explicitly mark it as publicly re-exported, and `X` is
+not included in `__all__`; whether it should be considered a "public name" in module `b` is
+ambiguous. We could consider an opt-in rule to warn the user when they use `X` in `c.py` that it was
+not included in `__all__` and was not marked as an explicit re-export.
+
+`a.py`:
+
+```py
+X: bool = True
+```
+
+`b.py`:
+
+```py
+from a import X
+```
+
+`c.py`:
+
+```py
+# TODO: should not error
+from b import *  # error: [unresolved-import]
+
+# TODO: this is a false positive, but we could consider a different opt-in diagnostic
+# (see prose commentary above)
+#
+# error: [unresolved-reference]
+reveal_type(X)  # revealed: Unknown
+```
+
+### Only explicit re-exports are considered re-exported from `.pyi` files
+
+For `.pyi` files, we should consider all imports private to the stub unless they are included in
+`__all__` or use the explict `from foo import X as X` syntax.
+
+`a.pyi`:
+
+```pyi
+X: bool = True
+```
+
+`b.pyi`:
+
+```pyi
+from a import X
+```
+
+`c.py`:
+
+```py
+# TODO: should not error
+from b import *  # error: [unresolved-import]
+
+# This error is correct, as `X` is not considered re-exported from module `b`:
+#
+# error: [unresolved-reference]
+reveal_type(X)  # revealed: Unknown
+```
+
 ### Symbols in statically known branches
 
 ```toml
@@ -190,17 +316,22 @@ reveal_type(X)  # revealed: Unknown
 
 ## Star imports with `__all__`
 
-If a module `x` contains `__all__`, only symbols included in `x.__all__` are imported by
-`from x import *`.
+If a module `x` contains `__all__`, all symbols included in `x.__all__` are imported by
+`from x import *` (but no other symbols are).
 
 ### Simple tuple `__all__`
 
 `a.py`:
 
 ```py
-__all__ = ("X",)
+__all__ = ("X", "_private", "__protected", "__dunder__", "___thunder___")
 
 X: bool = True
+_private: bool = True
+__protected: bool = True
+__dunder__: bool = True
+___thunder___: bool = True
+
 Y: bool = False
 ```
 
@@ -210,10 +341,20 @@ Y: bool = False
 # TODO should not error
 from a import *  # error: [unresolved-import]
 
-# TODO should not error, should reveal `bool`
+# TODO none of these should error, should all reveal `bool`
 # error: [unresolved-reference]
 reveal_type(X)  # revealed: Unknown
+# error: [unresolved-reference]
+reveal_type(_private)  # revealed: Unknown
+# error: [unresolved-reference]
+reveal_type(__protected)  # revealed: Unknown
+# error: [unresolved-reference]
+reveal_type(__dunder__)  # revealed: Unknown
+# error: [unresolved-reference]
+reveal_type(___thunder___)  # revealed: Unknown
 
+# but this diagnostic is accurate!
+#
 # error: [unresolved-reference]
 reveal_type(Y)  # revealed: Unknown
 ```
@@ -361,16 +502,22 @@ from a import *  # fails with `AttributeError: module 'foo' has no attribute 'b'
 
 ### Dynamic `__all__`
 
-We'll need to decide what to do if `__all__` contains members that are dynamically computed. Mypy
-simply ignores any members that are not statically known when determining which symbols are
-available (which can lead to false positives).
+If `__all__` contains members that are dynamically computed, we should check that all members of
+`__all__` are assignable to `str`. For the purposes of evaluating `*` imports, however, we should
+treat the module as though it has no `__all__` at all: all global-scope members of the module should
+be considered imported by the import statement. We should probably also emit a warning telling the
+user that we cannot statically determine the elements of `__all__`.
 
 `a.py`:
 
 ```py
 def f() -> str:
     return "f"
 
+def g() -> int:
+    return 42
+
+# TODO we should emit a warning here for the dynamically constructed `__all__` member.
 __all__ = [f()]
 ```
 
@@ -380,14 +527,57 @@ __all__ = [f()]
 # TODO: should not error
 from a import *  # error: [unresolved-import]
 
-# Strictly speaking this is a false positive, since there *is* an `f` symbol imported
-# by the `*` import at runtime.
+# TODO: we should avoid both errors here.
+#
+# At runtime, `f` is imported but `g` is not; to avoid false positives, however,
+# we should treat `a` as though it does not have `__all__` at all,
+# which would imply that both symbols would be present.
 #
 # error: [unresolved-reference]
 reveal_type(f)  # revealed: Unknown
+# error: [unresolved-reference]
+reveal_type(g)  # revealed: Unknown
 ```
 
-### `__all__` combined with statically known branches
+### `__all__` conditionally defined in a statically known branch
+
+```toml
+[environment]
+python-version = "3.11"
+```
+
+`a.py`:
+
+```py
+import sys
+
+X: bool = True
+
+if sys.version_info >= (3, 11):
+    __all__ = ["X", "Y"]
+    Y: bool = True
+else:
+    __all__ = ("Z",)
+    Z: bool = True
+```
+
+`b.py`:
+
+```py
+# TODO should not error
+from a import *  # error: [unresolved-import]
+
+# TODO neither should error, both should be `bool`
+# error: [unresolved-reference]
+reveal_type(X)  # revealed: Unknown
+# error: [unresolved-reference]
+reveal_type(Y)  # revealed: Unknown
+
+# error: [unresolved-reference]
+reveal_type(Z)  # revealed: Unknown
+```
+
+### `__all__` conditionally mutated in a statically known branch
 
 ```toml
 [environment]
@@ -426,6 +616,75 @@ reveal_type(Y)  # revealed: Unknown
 reveal_type(Z)  # revealed: Unknown
 ```
 
+### Empty `__all__`
+
+An empty `__all__` is valid, but a `*` import from a module with an empty `__all__` results in 0
+bindings being added from the import:
+
+`a.py`:
+
+```py
+X: bool = True
+
+__all__ = ()
+```
+
+`b.py`:
+
+```py
+Y: bool = True
+
+__all__ = []
+```
+
+`c.py`:
+
+```py
+# TODO: should not error for either import statement:
+from a import *  # error: [unresolved-import]
+from b import *  # error: [unresolved-import]
+
+# error: [unresolved-reference]
+reveal_type(X)  # revealed: Unknown
+# error: [unresolved-reference]
+reveal_type(Y)  # revealed: Unknown
+```
+
+### `__all__` in a stub file
+
+If a name is included in `__all__` in a stub file, it is considered re-exported even if it was only
+defined using an import without the explicit `from foo import X as X` syntax:
+
+`a.py`:
+
+```py
+X: bool = True
+Y: bool = True
+```
+
+`b.py`:
+
+```py
+from a import X, Y
+
+__all__ = ["X"]
+```
+
+`c.py`:
+
+```py
+# TODO: should not error
+from b import *  # error: [unresolved-import]
+
+# TODO: should not error, should reveal `bool`
+# error: [unresolved-reference]
+reveal_type(X)  # revealed: Unknown
+
+# this error is correct:
+# error: [unresolved-reference]
+reveal_type(Y)  # revealed: Unknown
+```
+
 ## Integration test: `collections.abc`
 
 The `collections.abc` standard-library module provides a good integration test, as all its symbols
@@ -452,4 +711,28 @@ If the module is unresolved, we emit a diagnostic just like for any other unreso
 from foo import *  # error: [unresolved-import]
 ```
 
+### Nested scope
+
+A `*` import in a nested scope are always a syntax error. Red-knot does not infer any bindings from
+them:
+
+`a.py`:
+
+```py
+X: bool = True
+```
+
+`b.py`:
+
+```py
+def f():
+    # TODO: it's correct for us to raise an error here, but the error code and error message are incorrect.
+    # It should be a syntax errror (tracked by https://github.com/astral-sh/ruff/issues/11934)
+    from a import *  # error: [unresolved-import] "Module `a` has no member `*`"
+
+    # error: [unresolved-reference]
+    reveal_type(X)  # revealed: Unknown
+```
+
+[python language reference for import statements]: https://docs.python.org/3/reference/simple_stmts.html#the-import-statement
 [typing spec]: https://typing.python.org/en/latest/spec/distributing.html#library-interface-public-and-private-symbols