Move visibility module into ast crate (#3367)

crates/ruff/src/ast/context.rs

@@ -9,8 +9,8 @@ use ruff_python_stdlib::typing::TYPING_EXTENSIONS;
 
 use crate::ast::helpers::{collect_call_path, from_relative_import, Exceptions};
 use crate::ast::types::{Binding, BindingKind, CallPath, ExecutionContext, RefEquality, Scope};
+use crate::ast::visibility::{module_visibility, Modifier, VisibleScope};
 use crate::resolver::is_interface_definition_path;
-use crate::visibility::{module_visibility, Modifier, VisibleScope};
 
 #[allow(clippy::struct_excessive_bools)]
 pub struct Context<'a> {

crates/ruff/src/ast/mod.rs

@@ -11,5 +11,6 @@ pub mod relocate;
 pub mod strings;
 pub mod types;
 pub mod typing;
+pub mod visibility;
 pub mod visitor;
 pub mod whitespace;

crates/ruff/src/visibility.rs → crates/ruff/src/ast/visibility.rs

@@ -1,14 +1,10 @@
-//! Abstractions for tracking public and private visibility across modules,
-//! classes, and functions.
-
 use std::path::Path;
 
 use rustpython_parser::ast::{Expr, Stmt, StmtKind};
 
 use crate::ast::context::Context;
 use crate::ast::helpers::{collect_call_path, map_callable};
 use crate::ast::types::CallPath;
-use crate::docstrings::definition::Documentable;
 
 #[derive(Debug, Clone)]
 pub enum Modifier {
@@ -159,7 +155,7 @@ pub fn module_visibility(path: &Path) -> Visibility {
     Visibility::Public
 }
 
-fn function_visibility(stmt: &Stmt) -> Visibility {
+pub fn function_visibility(stmt: &Stmt) -> Visibility {
     match &stmt.node {
         StmtKind::FunctionDef { name, .. } | StmtKind::AsyncFunctionDef { name, .. } => {
             if name.starts_with('_') {
@@ -172,7 +168,7 @@ fn function_visibility(stmt: &Stmt) -> Visibility {
     }
 }
 
-fn method_visibility(stmt: &Stmt) -> Visibility {
+pub fn method_visibility(stmt: &Stmt) -> Visibility {
     match &stmt.node {
         StmtKind::FunctionDef {
             name,
@@ -209,7 +205,7 @@ fn method_visibility(stmt: &Stmt) -> Visibility {
     }
 }
 
-fn class_visibility(stmt: &Stmt) -> Visibility {
+pub fn class_visibility(stmt: &Stmt) -> Visibility {
     match &stmt.node {
         StmtKind::ClassDef { name, .. } => {
             if name.starts_with('_') {
@@ -221,40 +217,3 @@ fn class_visibility(stmt: &Stmt) -> Visibility {
         _ => panic!("Found non-ClassDef in function_visibility"),
     }
 }
-
-/// Transition a `VisibleScope` based on a new `Documentable` definition.
-///
-/// `scope` is the current `VisibleScope`, while `Documentable` and `Stmt`
-/// describe the current node used to modify visibility.
-pub fn transition_scope(scope: &VisibleScope, stmt: &Stmt, kind: &Documentable) -> VisibleScope {
-    match kind {
-        Documentable::Function => VisibleScope {
-            modifier: Modifier::Function,
-            visibility: match scope {
-                VisibleScope {
-                    modifier: Modifier::Module,
-                    visibility: Visibility::Public,
-                } => function_visibility(stmt),
-                VisibleScope {
-                    modifier: Modifier::Class,
-                    visibility: Visibility::Public,
-                } => method_visibility(stmt),
-                _ => Visibility::Private,
-            },
-        },
-        Documentable::Class => VisibleScope {
-            modifier: Modifier::Class,
-            visibility: match scope {
-                VisibleScope {
-                    modifier: Modifier::Module,
-                    visibility: Visibility::Public,
-                } => class_visibility(stmt),
-                VisibleScope {
-                    modifier: Modifier::Class,
-                    visibility: Visibility::Public,
-                } => class_visibility(stmt),
-                _ => Visibility::Private,
-            },
-        },
-    }
-}

crates/ruff/src/checkers/ast/deferred.rs

@@ -1,9 +1,9 @@
 use rustpython_parser::ast::{Expr, Stmt};
 
 use crate::ast::types::RefEquality;
+use crate::ast::visibility::{Visibility, VisibleScope};
 use crate::checkers::ast::AnnotationContext;
 use crate::docstrings::definition::Definition;
-use crate::visibility::{Visibility, VisibleScope};
 use crate::Range;
 
 type Context<'a> = (Vec<usize>, Vec<RefEquality<'a, Stmt>>);

crates/ruff/src/checkers/ast/mod.rs

@@ -25,9 +25,11 @@ use crate::ast::types::{
 };
 use crate::ast::typing::{match_annotated_subscript, Callable, SubscriptKind};
 use crate::ast::visitor::{walk_excepthandler, walk_pattern, Visitor};
-use crate::ast::{branch_detection, cast, helpers, operations, typing, visitor};
+use crate::ast::{branch_detection, cast, helpers, operations, typing, visibility, visitor};
 use crate::checkers::ast::deferred::Deferred;
-use crate::docstrings::definition::{Definition, DefinitionKind, Docstring, Documentable};
+use crate::docstrings::definition::{
+    transition_scope, Definition, DefinitionKind, Docstring, Documentable,
+};
 use crate::registry::{Diagnostic, Rule};
 use crate::resolver::is_interface_definition_path;
 use crate::rules::{
@@ -42,8 +44,7 @@ use crate::rules::{
 use crate::settings::types::PythonVersion;
 use crate::settings::{flags, Settings};
 use crate::source_code::{Indexer, Locator, Stylist};
-use crate::visibility::transition_scope;
-use crate::{ast, autofix, docstrings, noqa, visibility};
+use crate::{ast, autofix, docstrings, noqa};
 
 mod deferred;
 

crates/ruff/src/docstrings/definition.rs

@@ -1,3 +1,6 @@
+use crate::ast::visibility::{
+    class_visibility, function_visibility, method_visibility, Modifier, Visibility, VisibleScope,
+};
 use rustpython_parser::ast::{Expr, Stmt};
 
 #[derive(Debug, Clone)]
@@ -30,3 +33,36 @@ pub enum Documentable {
     Class,
     Function,
 }
+
+pub fn transition_scope(scope: &VisibleScope, stmt: &Stmt, kind: &Documentable) -> VisibleScope {
+    match kind {
+        Documentable::Function => VisibleScope {
+            modifier: Modifier::Function,
+            visibility: match scope {
+                VisibleScope {
+                    modifier: Modifier::Module,
+                    visibility: Visibility::Public,
+                } => function_visibility(stmt),
+                VisibleScope {
+                    modifier: Modifier::Class,
+                    visibility: Visibility::Public,
+                } => method_visibility(stmt),
+                _ => Visibility::Private,
+            },
+        },
+        Documentable::Class => VisibleScope {
+            modifier: Modifier::Class,
+            visibility: match scope {
+                VisibleScope {
+                    modifier: Modifier::Module,
+                    visibility: Visibility::Public,
+                } => class_visibility(stmt),
+                VisibleScope {
+                    modifier: Modifier::Class,
+                    visibility: Visibility::Public,
+                } => class_visibility(stmt),
+                _ => Visibility::Private,
+            },
+        },
+    }
+}

crates/ruff/src/docstrings/extraction.rs

@@ -2,8 +2,8 @@
 
 use rustpython_parser::ast::{Constant, Expr, ExprKind, Stmt, StmtKind};
 
+use crate::ast::visibility::{Modifier, VisibleScope};
 use crate::docstrings::definition::{Definition, DefinitionKind, Documentable};
-use crate::visibility::{Modifier, VisibleScope};
 
 /// Extract a docstring from a function or class body.
 pub fn docstring_from(suite: &[Stmt]) -> Option<&Expr> {

crates/ruff/src/lib.rs

@@ -35,7 +35,6 @@ mod rules;
 pub mod settings;
 pub mod source_code;
 mod violation;
-mod visibility;
 
 cfg_if! {
     if #[cfg(target_family = "wasm")] {

crates/ruff/src/rules/flake8_annotations/helpers.rs

@@ -1,9 +1,9 @@
 use rustpython_parser::ast::{Arguments, Expr, Stmt, StmtKind};
 
 use crate::ast::cast;
+use crate::ast::visibility;
 use crate::checkers::ast::Checker;
 use crate::docstrings::definition::{Definition, DefinitionKind};
-use crate::visibility;
 
 pub(super) fn match_function_def(
     stmt: &Stmt,

crates/ruff/src/rules/flake8_annotations/rules.rs

@@ -6,14 +6,14 @@ use super::fixes;
 use super::helpers::match_function_def;
 use crate::ast::helpers::ReturnStatementVisitor;
 use crate::ast::types::Range;
+use crate::ast::visibility;
+use crate::ast::visibility::Visibility;
 use crate::ast::visitor::Visitor;
 use crate::ast::{cast, helpers};
 use crate::checkers::ast::Checker;
 use crate::docstrings::definition::{Definition, DefinitionKind};
 use crate::registry::{Diagnostic, Rule};
 use crate::violation::{AlwaysAutofixableViolation, Violation};
-use crate::visibility;
-use crate::visibility::Visibility;
 
 /// ## What it does
 /// Checks that function arguments have type annotations.

crates/ruff/src/rules/flake8_bugbear/rules/abstract_base_class.rs

@@ -2,10 +2,10 @@ use ruff_macros::{derive_message_formats, violation};
 use rustpython_parser::ast::{Constant, Expr, ExprKind, Keyword, Stmt, StmtKind};
 
 use crate::ast::types::Range;
+use crate::ast::visibility::{is_abstract, is_overload};
 use crate::checkers::ast::Checker;
 use crate::registry::{Diagnostic, Rule};
 use crate::violation::Violation;
-use crate::visibility::{is_abstract, is_overload};
 
 #[violation]
 pub struct AbstractBaseClassWithoutAbstractMethod {

crates/ruff/src/rules/flake8_unused_arguments/rules.rs

@@ -10,10 +10,10 @@ use super::types::Argumentable;
 use crate::ast::function_type;
 use crate::ast::function_type::FunctionType;
 use crate::ast::types::{Binding, FunctionDef, Lambda, Scope, ScopeKind};
+use crate::ast::visibility;
 use crate::checkers::ast::Checker;
 use crate::registry::Diagnostic;
 use crate::violation::Violation;
-use crate::visibility;
 
 #[violation]
 pub struct UnusedFunctionArgument {

crates/ruff/src/rules/pydocstyle/rules/if_needed.rs

@@ -2,11 +2,11 @@ use ruff_macros::{derive_message_formats, violation};
 
 use crate::ast::cast;
 use crate::ast::helpers::identifier_range;
+use crate::ast::visibility::is_overload;
 use crate::checkers::ast::Checker;
 use crate::docstrings::definition::{DefinitionKind, Docstring};
 use crate::registry::Diagnostic;
 use crate::violation::Violation;
-use crate::visibility::is_overload;
 
 #[violation]
 pub struct OverloadWithDocstring;

crates/ruff/src/rules/pydocstyle/rules/non_imperative_mood.rs

@@ -7,12 +7,12 @@ use ruff_macros::{derive_message_formats, violation};
 use crate::ast::cast;
 use crate::ast::helpers::to_call_path;
 use crate::ast::types::{CallPath, Range};
+use crate::ast::visibility::{is_property, is_test};
 use crate::checkers::ast::Checker;
 use crate::docstrings::definition::{DefinitionKind, Docstring};
 use crate::registry::Diagnostic;
 use crate::rules::pydocstyle::helpers::normalize_word;
 use crate::violation::Violation;
-use crate::visibility::{is_property, is_test};
 
 static MOOD: Lazy<Mood> = Lazy::new(Mood::new);
 

crates/ruff/src/rules/pydocstyle/rules/not_missing.rs

@@ -3,12 +3,14 @@ use ruff_macros::{derive_message_formats, violation};
 use crate::ast::cast;
 use crate::ast::helpers::identifier_range;
 use crate::ast::types::Range;
+use crate::ast::visibility::{
+    is_call, is_init, is_magic, is_new, is_overload, is_override, Visibility,
+};
 use crate::checkers::ast::Checker;
 use crate::docstrings::definition::{Definition, DefinitionKind};
 use crate::message::Location;
 use crate::registry::{Diagnostic, Rule};
 use crate::violation::Violation;
-use crate::visibility::{is_call, is_init, is_magic, is_new, is_overload, is_override, Visibility};
 
 #[violation]
 pub struct PublicModule;

crates/ruff/src/rules/pydocstyle/rules/sections.rs

@@ -8,6 +8,7 @@ use ruff_macros::{derive_message_formats, violation};
 
 use crate::ast::helpers::identifier_range;
 use crate::ast::types::Range;
+use crate::ast::visibility::is_staticmethod;
 use crate::ast::whitespace::LinesWithTrailingNewline;
 use crate::ast::{cast, whitespace};
 use crate::checkers::ast::Checker;
@@ -19,7 +20,6 @@ use crate::message::Location;
 use crate::registry::{Diagnostic, Rule};
 use crate::rules::pydocstyle::settings::Convention;
 use crate::violation::{AlwaysAutofixableViolation, Violation};
-use crate::visibility::is_staticmethod;
 
 #[violation]
 pub struct SectionNotOverIndented {