mirror of
https://github.com/astral-sh/ruff.git
synced 2025-08-04 02:39:12 +00:00
d574fcd1ac
## Summary This PR implements validation in the formatter tests to ensure that we don't modify the AST during formatting. Black has similar logic. In implementing this, I learned that Black actually _does_ modify the AST, and their test infrastructure normalizes the AST to wipe away those differences. Specifically, Black changes the indentation of docstrings, which _does_ modify the AST; and it also inserts parentheses in `del` statements, which changes the AST too. Ruff also does both these things, so we _also_ implement the same normalization using a new visitor that allows for modifying the AST. Closes https://github.com/astral-sh/ruff/issues/8184. ## Test Plan `cargo test`
83 lines
3 KiB
Rust
83 lines
3 KiB
Rust
use itertools::Either::{Left, Right};
|
|
|
|
use ruff_python_ast::visitor::transformer;
|
|
use ruff_python_ast::visitor::transformer::Transformer;
|
|
use ruff_python_ast::{self as ast, Expr, Stmt};
|
|
|
|
/// A struct to normalize AST nodes for the purpose of comparing formatted representations for
|
|
/// semantic equivalence.
|
|
///
|
|
/// Vis-à-vis comparing ASTs, comparing these normalized representations does the following:
|
|
/// - Ignores non-abstraction information that we've encoded into the AST, e.g., the difference
|
|
/// between `class C: ...` and `class C(): ...`, which is part of our AST but not `CPython`'s.
|
|
/// - Normalize strings. The formatter can re-indent docstrings, so we need to compare string
|
|
/// contents ignoring whitespace. (Black does the same.)
|
|
/// - Ignores nested tuples in deletions. (Black does the same.)
|
|
pub(crate) struct Normalizer;
|
|
|
|
impl Normalizer {
|
|
/// Transform an AST module into a normalized representation.
|
|
#[allow(dead_code)]
|
|
pub(crate) fn visit_module(&self, module: &mut ast::Mod) {
|
|
match module {
|
|
ast::Mod::Module(module) => {
|
|
self.visit_body(&mut module.body);
|
|
}
|
|
ast::Mod::Expression(expression) => {
|
|
self.visit_expr(&mut expression.body);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
impl Transformer for Normalizer {
|
|
fn visit_stmt(&self, stmt: &mut Stmt) {
|
|
match stmt {
|
|
Stmt::ClassDef(class_def) => {
|
|
// Treat `class C: ...` and `class C(): ...` equivalently.
|
|
if class_def
|
|
.arguments
|
|
.as_ref()
|
|
.is_some_and(|arguments| arguments.is_empty())
|
|
{
|
|
class_def.arguments = None;
|
|
}
|
|
}
|
|
Stmt::Delete(delete) => {
|
|
// Treat `del a, b` and `del (a, b)` equivalently.
|
|
delete.targets = delete
|
|
.targets
|
|
.clone()
|
|
.into_iter()
|
|
.flat_map(|target| {
|
|
if let Expr::Tuple(tuple) = target {
|
|
Left(tuple.elts.into_iter())
|
|
} else {
|
|
Right(std::iter::once(target))
|
|
}
|
|
})
|
|
.collect();
|
|
}
|
|
_ => {}
|
|
}
|
|
|
|
transformer::walk_stmt(self, stmt);
|
|
}
|
|
|
|
fn visit_expr(&self, expr: &mut Expr) {
|
|
if let Expr::StringLiteral(string_literal) = expr {
|
|
// Normalize a string by (1) stripping any leading and trailing space from each
|
|
// line, and (2) removing any blank lines from the start and end of the string.
|
|
string_literal.value = string_literal
|
|
.value
|
|
.lines()
|
|
.map(str::trim)
|
|
.collect::<Vec<_>>()
|
|
.join("\n")
|
|
.trim()
|
|
.to_owned();
|
|
}
|
|
|
|
transformer::walk_expr(self, expr);
|
|
}
|
|
}
|