[red-knot] Add support for import conventions

Author: dhruvmanila

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

@@ -0,0 +1,86 @@
+# Import conventions
+
+Tests that validates the import conventions.
+
+Reference:
+* <https://typing.readthedocs.io/en/latest/spec/distributing.html#import-conventions>
+
+## Builtins scope
+
+When looking up for a name, red knot will fallback to using the builtins scope
+if the name is not found in the current scope. The `builtins.pyi` file, that will
+be used to resolve any symbol in the builtins scope, contains multiple symbols
+from other modules (e.g., `typing`) but those are not being re-exported.
+
+```py
+# These symbols are being imported in `builtins.pyi` but shouldn't be considered as being
+# available in the builtins scope.
+
+# error: "Name `Literal` used when not defined"
+a: Literal[1] = 1
+
+# error: "Name `sys` used when not defined"
+reveal_type(sys.executable)  # revealed: str
+```
+
+## Builtins import
+
+Try to import the symbols from the module which aren't explicitly exporting them.
+
+```py
+# error: "Module `builtins` does not explicitly export attribute `Literal`"
+# error: "Module `builtins` does not explicitly export attribute `sys`"
+from builtins import Literal, sys
+
+# TODO: This should be an error but we don't understand `*` imports yet and
+# the `collections.abc` uses `from _collections_abc import *`.
+from math import Iterable
+```
+
+## Explicitly re-exported symbols
+
+When explicitly re-exporting a symbol or a module, it should not raise an error
+when importing it. This tests both `import ...` and `from ... import ...` forms.
+
+Note: Submodule imports in `import ...` form doesn't work because it's a syntax
+error. For example, in `import os.path as os.path` the `os.path` is not a valid
+identifier.
+
+```py
+from b import Any, Literal, ast
+
+reveal_type(Any)  # revealed: typing.Any
+reveal_type(Literal)  # revealed: typing.Literal
+reveal_type(ast)  # revealed: <module 'ast'>
+```
+
+```pyi path=b.pyi
+import ast as ast
+from typing import Any as Any, Literal as Literal
+```
+
+## Implicitly re-exported symbols
+
+Here, none of the symbols are being re-exported in the stub file. Regardless,
+we should still infer the types correctly.
+
+```py
+# error: 15 [implicit-reexport] "Module `b` does not explicitly export attribute `ast`"
+# error: 20 [implicit-reexport] "Module `b` does not explicitly export attribute `Any`"
+# error: 25 [implicit-reexport] "Module `b` does not explicitly export attribute `Literal`"
+from b import ast, Any, Literal
+
+reveal_type(Any)  # revealed: typing.Any
+reveal_type(Literal)  # revealed: typing.Literal
+reveal_type(ast)  # revealed: <module 'ast'>
+```
+
+```pyi path=b.pyi
+import ast
+from typing import Any, Literal
+```
+
+TODO:
+* Conditional imports
+* `__init__` files even though we don't special case it
+* Submodule imports

crates/red_knot_python_semantic/src/symbol.rs

@@ -18,6 +18,30 @@ impl Boundness {
     }
 }
 
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub(crate) enum ReExport {
+    Implicit,
+    Explicit,
+    None,
+}
+
+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::Explicit) | (ReExport::Explicit, ReExport::Implicit) => {
+                ReExport::Explicit
+            }
+            (ReExport::Implicit, ReExport::Implicit) => ReExport::Implicit,
+            (ReExport::Explicit, ReExport::Explicit) => ReExport::Explicit,
+            (non_none, ReExport::None) | (ReExport::None, non_none) => non_none,
+        }
+    }
+}
+
 /// The result of a symbol lookup, which can either be a (possibly unbound) type
 /// or a completely unbound symbol.
 ///
@@ -37,7 +61,7 @@ impl Boundness {
 /// ```
 #[derive(Debug, Clone, PartialEq, Eq)]
 pub(crate) enum Symbol<'db> {
-    Type(Type<'db>, Boundness),
+    Type(Type<'db>, ReExport, Boundness),
     Unbound,
 }
 
@@ -48,8 +72,8 @@ impl<'db> Symbol<'db> {
 
     pub(crate) fn possibly_unbound(&self) -> bool {
         match self {
-            Symbol::Type(_, Boundness::PossiblyUnbound) | Symbol::Unbound => true,
-            Symbol::Type(_, Boundness::Bound) => false,
+            Symbol::Type(_, _, Boundness::PossiblyUnbound) | Symbol::Unbound => true,
+            Symbol::Type(_, _, Boundness::Bound) => false,
         }
     }
 
@@ -59,7 +83,7 @@ impl<'db> Symbol<'db> {
     /// if there is at least one control-flow path where the symbol is bound, return the type.
     pub(crate) fn ignore_possibly_unbound(&self) -> Option<Type<'db>> {
         match self {
-            Symbol::Type(ty, _) => Some(*ty),
+            Symbol::Type(ty, _, _) => Some(*ty),
             Symbol::Unbound => None,
         }
     }
@@ -74,12 +98,15 @@ impl<'db> Symbol<'db> {
     #[must_use]
     pub(crate) fn or_fall_back_to(self, db: &'db dyn Db, fallback: &Symbol<'db>) -> Symbol<'db> {
         match fallback {
-            Symbol::Type(fallback_ty, fallback_boundness) => match self {
-                Symbol::Type(_, Boundness::Bound) => self,
-                Symbol::Type(ty, boundness @ Boundness::PossiblyUnbound) => Symbol::Type(
-                    UnionType::from_elements(db, [*fallback_ty, ty]),
-                    fallback_boundness.or(boundness),
-                ),
+            Symbol::Type(fallback_ty, fallback_re_export, fallback_boundness) => match self {
+                Symbol::Type(_, _, Boundness::Bound) => self,
+                Symbol::Type(ty, re_export, boundness @ Boundness::PossiblyUnbound) => {
+                    Symbol::Type(
+                        UnionType::from_elements(db, [*fallback_ty, ty]),
+                        fallback_re_export.or(re_export),
+                        fallback_boundness.or(boundness),
+                    )
+                }
                 Symbol::Unbound => fallback.clone(),
             },
             Symbol::Unbound => self,
@@ -89,7 +116,7 @@ impl<'db> Symbol<'db> {
     #[must_use]
     pub(crate) fn map_type(self, f: impl FnOnce(Type<'db>) -> Type<'db>) -> Symbol<'db> {
         match self {
-            Symbol::Type(ty, boundness) => Symbol::Type(f(ty), boundness),
+            Symbol::Type(ty, re_export, boundness) => Symbol::Type(f(ty), re_export, boundness),
             Symbol::Unbound => Symbol::Unbound,
         }
     }
@@ -114,41 +141,54 @@ mod tests {
             Symbol::Unbound
         );
         assert_eq!(
-            Symbol::Unbound.or_fall_back_to(&db, &Symbol::Type(ty1, PossiblyUnbound)),
-            Symbol::Type(ty1, PossiblyUnbound)
+            Symbol::Unbound
+                .or_fall_back_to(&db, &Symbol::Type(ty1, ReExport::None, PossiblyUnbound)),
+            Symbol::Type(ty1, ReExport::None, PossiblyUnbound)
         );
         assert_eq!(
-            Symbol::Unbound.or_fall_back_to(&db, &Symbol::Type(ty1, Bound)),
-            Symbol::Type(ty1, Bound)
+            Symbol::Unbound.or_fall_back_to(&db, &Symbol::Type(ty1, ReExport::None, Bound)),
+            Symbol::Type(ty1, ReExport::None, Bound)
         );
 
         // Start from a possibly unbound symbol
         assert_eq!(
-            Symbol::Type(ty1, PossiblyUnbound).or_fall_back_to(&db, &Symbol::Unbound),
-            Symbol::Type(ty1, PossiblyUnbound)
+            Symbol::Type(ty1, ReExport::None, PossiblyUnbound)
+                .or_fall_back_to(&db, &Symbol::Unbound),
+            Symbol::Type(ty1, ReExport::None, PossiblyUnbound)
         );
         assert_eq!(
-            Symbol::Type(ty1, PossiblyUnbound)
-                .or_fall_back_to(&db, &Symbol::Type(ty2, PossiblyUnbound)),
-            Symbol::Type(UnionType::from_elements(&db, [ty2, ty1]), PossiblyUnbound)
+            Symbol::Type(ty1, ReExport::None, PossiblyUnbound)
+                .or_fall_back_to(&db, &Symbol::Type(ty2, ReExport::None, PossiblyUnbound)),
+            Symbol::Type(
+                UnionType::from_elements(&db, [ty2, ty1]),
+                ReExport::None,
+                PossiblyUnbound
+            )
         );
         assert_eq!(
-            Symbol::Type(ty1, PossiblyUnbound).or_fall_back_to(&db, &Symbol::Type(ty2, Bound)),
-            Symbol::Type(UnionType::from_elements(&db, [ty2, ty1]), Bound)
+            Symbol::Type(ty1, ReExport::None, PossiblyUnbound)
+                .or_fall_back_to(&db, &Symbol::Type(ty2, ReExport::None, Bound)),
+            Symbol::Type(
+                UnionType::from_elements(&db, [ty2, ty1]),
+                ReExport::None,
+                Bound
+            )
         );
 
         // Start from a definitely bound symbol
         assert_eq!(
-            Symbol::Type(ty1, Bound).or_fall_back_to(&db, &Symbol::Unbound),
-            Symbol::Type(ty1, Bound)
+            Symbol::Type(ty1, ReExport::None, Bound).or_fall_back_to(&db, &Symbol::Unbound),
+            Symbol::Type(ty1, ReExport::None, Bound)
         );
         assert_eq!(
-            Symbol::Type(ty1, Bound).or_fall_back_to(&db, &Symbol::Type(ty2, PossiblyUnbound)),
-            Symbol::Type(ty1, Bound)
+            Symbol::Type(ty1, ReExport::None, Bound)
+                .or_fall_back_to(&db, &Symbol::Type(ty2, ReExport::None, PossiblyUnbound)),
+            Symbol::Type(ty1, ReExport::None, Bound)
         );
         assert_eq!(
-            Symbol::Type(ty1, Bound).or_fall_back_to(&db, &Symbol::Type(ty2, Bound)),
-            Symbol::Type(ty1, Bound)
+            Symbol::Type(ty1, ReExport::None, Bound)
+                .or_fall_back_to(&db, &Symbol::Type(ty2, ReExport::None, Bound)),
+            Symbol::Type(ty1, ReExport::None, Bound)
         );
     }
 }