Make it work for attributes on modules as well

crates/red_knot_python_semantic/resources/mdtest/scopes/moduletype_attrs.md

@@ -20,7 +20,9 @@ reveal_type(__spec__)  # revealed: @Todo
 reveal_type(__path__)  # revealed: @Todo
 
 # TODO: this should probably be added to typeshed; not sure why it isn't?
-reveal_type(__doc__)  # revealed: Unbound
+# error: [unresolved-reference]
+# revealed: Unbound
+reveal_type(__doc__)
 
 class X:
     reveal_type(__name__)  # revealed: str
@@ -33,9 +35,28 @@ However, three attributes on `types.ModuleType` are not present as implicit
 module globals; these are excluded:
 
 ```py path=unbound_dunders.py
-reveal_type(__getattr__)  # revealed: Unbound
-reveal_type(__dict__)  # revealed: Unbound
-reveal_type(__init__)  # revealed: Unbound
+# error: [unresolved-reference]
+# revealed: Unbound
+reveal_type(__getattr__)
+
+# error: [unresolved-reference]
+# revealed: Unbound
+reveal_type(__dict__)
+
+# error: [unresolved-reference]
+# revealed: Unbound
+reveal_type(__init__)
+```
+
+## Accessed as attributes
+
+`ModuleType` attributes can also be accessed as attributes
+on module-literal inhabitants:
+
+```py
+import typing
+
+reveal_type(typing.__name__)  # revealed: str
 ```
 
 ## Conditionally global or `ModuleType` attribute

crates/red_knot_python_semantic/src/types.rs

@@ -90,7 +90,24 @@ fn symbol_ty<'db>(db: &'db dyn Db, scope: ScopeId<'db>, name: &str) -> Type<'db>
 
 /// Shorthand for `symbol_ty` that looks up a module-global symbol by name in a file.
 pub(crate) fn global_symbol_ty<'db>(db: &'db dyn Db, file: File, name: &str) -> Type<'db> {
-    symbol_ty(db, global_scope(db, file), name)
+    let explicit_ty = symbol_ty(db, global_scope(db, file), name);
+
+    // Not defined explicitly in the global scope?
+    // All modules are instances of `types.ModuleType`;
+    // look it up there (with a few very special exceptions)
+    if explicit_ty.may_be_unbound(db) && !matches!(name, "__dict__" | "__init__" | "__getattr__") {
+        // TODO: this should be `KnownClass::ModuleType.to_instance()`,
+        // but we don't yet support looking up attributes on instances
+        let module_type = KnownClass::ModuleType.to_class(db);
+        let module_type_member_ty = module_type.member(db, name);
+        if module_type_member_ty.is_unbound() {
+            explicit_ty
+        } else {
+            explicit_ty.replace_unbound_with(db, module_type_member_ty)
+        }
+    } else {
+        explicit_ty
+    }
 }
 
 /// Infer the type of a binding.

crates/red_knot_python_semantic/src/types/infer.rs

@@ -2363,20 +2363,6 @@ impl<'db> TypeInferenceBuilder<'db> {
                 global_symbol_ty(self.db, self.file, name)
             };
 
-            // Still possibly unbound? All modules are instances of `types.ModuleType`;
-            // look it up there (with a few very special exceptions)
-            if ty.may_be_unbound(self.db)
-                && !matches!(&**name, "__dict__" | "__init__" | "__getattr__")
-            {
-                // TODO: this should be `KnownClass::ModuleType.to_instance()`,
-                // but we don't yet support looking up attributes on instances
-                let module_type = KnownClass::ModuleType.to_class(self.db);
-                let module_type_member_ty = module_type.member(self.db, name);
-                if !module_type_member_ty.is_unbound() {
-                    return ty.replace_unbound_with(self.db, module_type_member_ty);
-                }
-            }
-
             // Fallback to builtins (without infinite recursion if we're already in builtins.)
             if ty.may_be_unbound(self.db) && Some(self.scope()) != builtins_module_scope(self.db) {
                 let mut builtin_ty = builtins_symbol_ty(self.db, name);