Apply Micha's suggestion

Author: AlexWaygood

crates/ruff_linter/src/checkers/ast/analyze/definitions.rs

@@ -93,7 +93,7 @@ pub(crate) fn definitions(checker: &mut Checker) {
     }
 
     // Compute visibility of all definitions.
-    let exports: Option<Vec<DunderAllName>> = {
+    let exports: Vec<DunderAllName> = {
         checker
             .semantic
             .global_scope()
@@ -106,14 +106,15 @@ pub(crate) fn definitions(checker: &mut Checker) {
             .fold(None, |acc, names| {
                 Some(acc.into_iter().flatten().chain(names).collect())
             })
+            .unwrap_or_default()
     };
 
     let definitions = std::mem::take(&mut checker.semantic.definitions);
     let mut overloaded_name: Option<String> = None;
     for ContextualizedDefinition {
         definition,
         visibility,
-    } in definitions.resolve(exports.as_deref()).iter()
+    } in definitions.resolve(&exports).iter()
     {
         let docstring = docstrings::extraction::extract_docstring(definition);
 

crates/ruff_python_semantic/src/definition.rs

@@ -187,7 +187,7 @@ impl<'a> Definitions<'a> {
     }
 
     /// Resolve the visibility of each definition in the collection.
-    pub fn resolve(self, exports: Option<&[DunderAllName]>) -> ContextualizedDefinitions<'a> {
+    pub fn resolve(self, exports: &[DunderAllName]) -> ContextualizedDefinitions<'a> {
         let mut definitions: IndexVec<DefinitionId, ContextualizedDefinition<'a>> =
             IndexVec::with_capacity(self.len());
 
@@ -201,9 +201,7 @@ impl<'a> Definitions<'a> {
                         MemberKind::Class(class) => {
                             let parent = &definitions[member.parent];
                             if parent.visibility.is_private()
-                                || exports.is_some_and(|exports| {
-                                    !exports.iter().any(|export| export.name == member.name())
-                                })
+                                || !exports.iter().any(|export| export.name == member.name())
                             {
                                 Visibility::Private
                             } else {
@@ -223,9 +221,7 @@ impl<'a> Definitions<'a> {
                         MemberKind::Function(function) => {
                             let parent = &definitions[member.parent];
                             if parent.visibility.is_private()
-                                || exports.is_some_and(|exports| {
-                                    !exports.iter().any(|export| export.name == member.name())
-                                })
+                                || !exports.iter().any(|export| export.name == member.name())
                             {
                                 Visibility::Private
                             } else {