mirrors/ruff
1
0
Fork 0
mirror of https://github.com/astral-sh/ruff.git synced 2025-10-02 14:51:25 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions 3

Improve ruff_python_semantic::all::extract_all_names() (#11335)

Browse source
This commit is contained in:
Alex Waygood 2024-05-08 17:09:31 +01:00 • committed by GitHub
parent 4541337f3d
commit dfe4291c0b
No known key found for this signature in database
GPG key ID: B5690EEEBB952194
8 changed files with 111 additions and 92 deletions
Download patch file Download diff file Expand all files Collapse all files

4
crates/ruff_linter/resources/test/fixtures/pyflakes/F822_1b.py vendored Normal file
View file

@ -0,0 +1,4 @@
import builtins
a = 1
__all__ = builtins.list(["a", "b"])

5
crates/ruff_linter/src/checkers/ast/mod.rs
View file

@ -49,7 +49,7 @@ use ruff_python_ast::{helpers, str, visitor, PySourceType};
use ruff_python_codegen::{Generator, Stylist};
use ruff_python_index::Indexer;
use ruff_python_parser::typing::{parse_type_annotation, AnnotationKind};
use ruff_python_semantic::all::{extract_all_names, DunderAllDefinition, DunderAllFlags};
use ruff_python_semantic::all::{DunderAllDefinition, DunderAllFlags};
use ruff_python_semantic::analyze::{imports, typing};
use ruff_python_semantic::{
BindingFlags, BindingId, BindingKind, Exceptions, Export, FromImport, Globals, Import, Module,
@ -1882,8 +1882,7 @@ impl<'a> Checker<'a> {
_ => false,
}
{
let (all_names, all_flags) =
extract_all_names(parent, |name| self.semantic.has_builtin_binding(name));
let (all_names, all_flags) = self.semantic.extract_dunder_all_names(parent);
if all_flags.intersects(DunderAllFlags::INVALID_OBJECT) {
flags |= BindingFlags::INVALID_ALL_OBJECT;

1
crates/ruff_linter/src/rules/pyflakes/mod.rs
View file

@ -161,6 +161,7 @@ mod tests {
#[test_case(Rule::UndefinedExport, Path::new("F822_0.py"))]
#[test_case(Rule::UndefinedExport, Path::new("F822_0.pyi"))]
#[test_case(Rule::UndefinedExport, Path::new("F822_1.py"))]
#[test_case(Rule::UndefinedExport, Path::new("F822_1b.py"))]
#[test_case(Rule::UndefinedExport, Path::new("F822_2.py"))]
#[test_case(Rule::UndefinedExport, Path::new("F822_3.py"))]
#[test_case(Rule::UndefinedLocal, Path::new("F823.py"))]

10
crates/ruff_linter/src/rules/pyflakes/snapshots/ruff_linter__rules__pyflakes__tests__F822_F822_1b.py.snap Normal file
View file

@ -0,0 +1,10 @@
---
source: crates/ruff_linter/src/rules/pyflakes/mod.rs
---
F822_1b.py:4:31: F822 Undefined name `b` in `__all__`
|
2 | a = 1
3 |
4 | __all__ = builtins.list(["a", "b"])
| ^^^ F822
|

2
crates/ruff_python_semantic/src/definition.rs
View file

@ -5,7 +5,6 @@ use std::fmt::Debug;
use std::ops::Deref;
use std::path::Path;
use crate::all::DunderAllName;
use ruff_index::{newtype_index, IndexSlice, IndexVec};
use ruff_python_ast::{self as ast, Stmt};
use ruff_text_size::{Ranged, TextRange};
@ -13,6 +12,7 @@ use ruff_text_size::{Ranged, TextRange};
use crate::analyze::visibility::{
class_visibility, function_visibility, method_visibility, module_visibility, Visibility,
};
use crate::model::all::DunderAllName;
/// Id uniquely identifying a definition in a program.
#[newtype_index]

1
crates/ruff_python_semantic/src/lib.rs
View file

@ -1,4 +1,3 @@
pub mod all;
pub mod analyze;
mod binding;
mod branches;

2
crates/ruff_python_semantic/src/model.rs
View file

@ -1,3 +1,5 @@
pub mod all;
use std::path::Path;
use bitflags::bitflags;

132
crates/ruff_python_semantic/src/all.rs → crates/ruff_python_semantic/src/model/all.rs
View file

@ -1,8 +1,12 @@
//! Utilities for semantic analysis of `__all__` definitions
use bitflags::bitflags;
use ruff_python_ast::{self as ast, helpers::map_subscript, Expr, Stmt};
use ruff_text_size::{Ranged, TextRange};
use crate::SemanticModel;
bitflags! {
#[derive(Default, Debug, Copy, Clone, PartialEq, Eq)]
pub struct DunderAllFlags: u8 {
@ -66,16 +70,15 @@ impl Ranged for DunderAllDefinition<'_> {
}
}
/// Extract the names bound to a given __all__ assignment.
///
/// Accepts a closure that determines whether a given name (e.g., `"list"`) is a Python builtin.
pub fn extract_all_names<F>(stmt: &Stmt, is_builtin: F) -> (Vec<DunderAllName>, DunderAllFlags)
where
F: Fn(&str) -> bool,
{
fn add_to_names<'a>(
elts: &'a [Expr],
names: &mut Vec<DunderAllName<'a>>,
impl<'a> SemanticModel<'a> {
/// Extract the names bound to a given __all__ assignment.
pub fn extract_dunder_all_names<'expr>(
&self,
stmt: &'expr Stmt,
) -> (Vec<DunderAllName<'expr>>, DunderAllFlags) {
fn add_to_names<'expr>(
elts: &'expr [Expr],
names: &mut Vec<DunderAllName<'expr>>,
flags: &mut DunderAllFlags,
) {
for elt in elts {
@ -90,10 +93,56 @@ where
}
}
fn extract_elts<F>(expr: &Expr, is_builtin: F) -> (Option<&[Expr]>, DunderAllFlags)
where
F: Fn(&str) -> bool,
{
let mut names: Vec<DunderAllName> = vec![];
let mut flags = DunderAllFlags::empty();
if let Some(value) = match stmt {
Stmt::Assign(ast::StmtAssign { value, .. }) => Some(value),
Stmt::AnnAssign(ast::StmtAnnAssign { value, .. }) => value.as_ref(),
Stmt::AugAssign(ast::StmtAugAssign { value, .. }) => Some(value),
_ => None,
} {
if let Expr::BinOp(ast::ExprBinOp { left, right, .. }) = value.as_ref() {
let mut current_left = left;
let mut current_right = right;
loop {
// Process the right side, which should be a "real" value.
let (elts, new_flags) = self.extract_dunder_all_elts(current_right);
flags |= new_flags;
if let Some(elts) = elts {
add_to_names(elts, &mut names, &mut flags);
}
// Process the left side, which can be a "real" value or the "rest" of the
// binary operation.
if let Expr::BinOp(ast::ExprBinOp { left, right, .. }) = current_left.as_ref() {
current_left = left;
current_right = right;
} else {
let (elts, new_flags) = self.extract_dunder_all_elts(current_left);
flags |= new_flags;
if let Some(elts) = elts {
add_to_names(elts, &mut names, &mut flags);
}
break;
}
}
} else {
let (elts, new_flags) = self.extract_dunder_all_elts(value);
flags |= new_flags;
if let Some(elts) = elts {
add_to_names(elts, &mut names, &mut flags);
}
}
}
(names, flags)
}
fn extract_dunder_all_elts<'expr>(
&self,
expr: &'expr Expr,
) -> (Option<&'expr [Expr]>, DunderAllFlags) {
match expr {
Expr::List(ast::ExprList { elts, .. }) => {
return (Some(elts), DunderAllFlags::empty());
@ -122,9 +171,10 @@ where
}) => {
// Allow `tuple()`, `list()`, and their generic forms, like `list[int]()`.
if arguments.keywords.is_empty() && arguments.args.len() <= 1 {
if let Expr::Name(ast::ExprName { id, .. }) = map_subscript(func) {
let id = id.as_str();
if matches!(id, "tuple" | "list") && is_builtin(id) {
if self
.resolve_builtin_symbol(map_subscript(func))
.is_some_and(|symbol| matches!(symbol, "tuple" | "list"))
{
let [arg] = arguments.args.as_ref() else {
return (None, DunderAllFlags::empty());
};
@ -144,58 +194,12 @@ where
}
}
}
}
Expr::Named(ast::ExprNamed { value, .. }) => {
// Allow, e.g., `__all__ += (value := ["A", "B"])`.
return extract_elts(value, is_builtin);
return self.extract_dunder_all_elts(value);
}
_ => {}
}
(None, DunderAllFlags::INVALID_FORMAT)
}
let mut names: Vec<DunderAllName> = vec![];
let mut flags = DunderAllFlags::empty();
if let Some(value) = match stmt {
Stmt::Assign(ast::StmtAssign { value, .. }) => Some(value),
Stmt::AnnAssign(ast::StmtAnnAssign { value, .. }) => value.as_ref(),
Stmt::AugAssign(ast::StmtAugAssign { value, .. }) => Some(value),
_ => None,
} {
if let Expr::BinOp(ast::ExprBinOp { left, right, .. }) = value.as_ref() {
let mut current_left = left;
let mut current_right = right;
loop {
// Process the right side, which should be a "real" value.
let (elts, new_flags) = extract_elts(current_right, |expr| is_builtin(expr));
flags |= new_flags;
if let Some(elts) = elts {
add_to_names(elts, &mut names, &mut flags);
}
// Process the left side, which can be a "real" value or the "rest" of the
// binary operation.
if let Expr::BinOp(ast::ExprBinOp { left, right, .. }) = current_left.as_ref() {
current_left = left;
current_right = right;
} else {
let (elts, new_flags) = extract_elts(current_left, |expr| is_builtin(expr));
flags |= new_flags;
if let Some(elts) = elts {
add_to_names(elts, &mut names, &mut flags);
}
break;
}
}
} else {
let (elts, new_flags) = extract_elts(value, |expr| is_builtin(expr));
flags |= new_flags;
if let Some(elts) = elts {
add_to_names(elts, &mut names, &mut flags);
}
}
}
(names, flags)
}