mirror of
https://github.com/astral-sh/ruff.git
synced 2026-11-22 17:43:09 +08:00
Carry the typed IDs returned by node constructors through parsing and recovery. Parse source-ordered argument and parameter lists directly. Keep ownership of the tree with the parsed module.
266 lines
8.4 KiB
Rust
266 lines
8.4 KiB
Rust
//! Tests for [`ruff_python_ast::token::parentheses_iterator`] and
|
|
//! [`ruff_python_ast::token::parenthesized_range`].
|
|
|
|
use ruff_python_ast::{
|
|
ExprKind, StmtKind,
|
|
token::{parentheses_iterator, parenthesized_range},
|
|
};
|
|
use ruff_python_parser::{parse_expression, parse_module};
|
|
|
|
#[test]
|
|
fn test_no_parentheses() {
|
|
let source = "x = 2 + 2";
|
|
let parsed = parse_module(source).expect("should parse valid python");
|
|
let tokens = parsed.tokens();
|
|
let module = parsed.syntax();
|
|
|
|
let stmt = module
|
|
.body()
|
|
.first()
|
|
.expect("module should have a statement");
|
|
let StmtKind::Assign(assign) = stmt.classify() else {
|
|
panic!("expected `Assign` statement, got {stmt:?}");
|
|
};
|
|
|
|
let result = parenthesized_range(assign.value(), stmt.into(), tokens);
|
|
assert_eq!(result, None);
|
|
}
|
|
|
|
#[test]
|
|
fn test_single_parentheses() {
|
|
let source = "x = (2 + 2)";
|
|
let parsed = parse_module(source).expect("should parse valid python");
|
|
let tokens = parsed.tokens();
|
|
let module = parsed.syntax();
|
|
|
|
let stmt = module
|
|
.body()
|
|
.first()
|
|
.expect("module should have a statement");
|
|
let StmtKind::Assign(assign) = stmt.classify() else {
|
|
panic!("expected `Assign` statement, got {stmt:?}");
|
|
};
|
|
|
|
let result = parenthesized_range(assign.value(), stmt.into(), tokens);
|
|
let range = result.expect("should find parentheses");
|
|
assert_eq!(&source[range], "(2 + 2)");
|
|
}
|
|
|
|
#[test]
|
|
fn test_double_parentheses() {
|
|
let source = "x = ((2 + 2))";
|
|
let parsed = parse_module(source).expect("should parse valid python");
|
|
let tokens = parsed.tokens();
|
|
let module = parsed.syntax();
|
|
|
|
let stmt = module
|
|
.body()
|
|
.first()
|
|
.expect("module should have a statement");
|
|
let StmtKind::Assign(assign) = stmt.classify() else {
|
|
panic!("expected `Assign` statement, got {stmt:?}");
|
|
};
|
|
|
|
let result = parenthesized_range(assign.value(), stmt.into(), tokens);
|
|
let range = result.expect("should find parentheses");
|
|
assert_eq!(&source[range], "((2 + 2))");
|
|
}
|
|
|
|
#[test]
|
|
fn test_parentheses_with_whitespace() {
|
|
let source = "x = ( 2 + 2 )";
|
|
let parsed = parse_module(source).expect("should parse valid python");
|
|
let tokens = parsed.tokens();
|
|
let module = parsed.syntax();
|
|
|
|
let stmt = module
|
|
.body()
|
|
.first()
|
|
.expect("module should have a statement");
|
|
let StmtKind::Assign(assign) = stmt.classify() else {
|
|
panic!("expected `Assign` statement, got {stmt:?}");
|
|
};
|
|
|
|
let result = parenthesized_range(assign.value(), stmt.into(), tokens);
|
|
let range = result.expect("should find parentheses");
|
|
assert_eq!(&source[range], "( 2 + 2 )");
|
|
}
|
|
|
|
#[test]
|
|
fn test_parentheses_with_comments() {
|
|
let source = "x = ( # comment\n 2 + 2\n)";
|
|
let parsed = parse_module(source).expect("should parse valid python");
|
|
let tokens = parsed.tokens();
|
|
let module = parsed.syntax();
|
|
|
|
let stmt = module
|
|
.body()
|
|
.first()
|
|
.expect("module should have a statement");
|
|
let StmtKind::Assign(assign) = stmt.classify() else {
|
|
panic!("expected `Assign` statement, got {stmt:?}");
|
|
};
|
|
|
|
let result = parenthesized_range(assign.value(), stmt.into(), tokens);
|
|
let range = result.expect("should find parentheses");
|
|
assert_eq!(&source[range], "( # comment\n 2 + 2\n)");
|
|
}
|
|
|
|
#[test]
|
|
fn test_parenthesized_range_multiple() {
|
|
let source = "x = (((2 + 2)))";
|
|
let parsed = parse_module(source).expect("should parse valid python");
|
|
let tokens = parsed.tokens();
|
|
let module = parsed.syntax();
|
|
|
|
let stmt = module
|
|
.body()
|
|
.first()
|
|
.expect("module should have a statement");
|
|
let StmtKind::Assign(assign) = stmt.classify() else {
|
|
panic!("expected `Assign` statement, got {stmt:?}");
|
|
};
|
|
|
|
let result = parenthesized_range(assign.value(), stmt.into(), tokens);
|
|
let range = result.expect("should find parentheses");
|
|
assert_eq!(&source[range], "(((2 + 2)))");
|
|
}
|
|
|
|
#[test]
|
|
fn test_parentheses_iterator_multiple() {
|
|
let source = "x = (((2 + 2)))";
|
|
let parsed = parse_module(source).expect("should parse valid python");
|
|
let tokens = parsed.tokens();
|
|
let module = parsed.syntax();
|
|
|
|
let stmt = module
|
|
.body()
|
|
.first()
|
|
.expect("module should have a statement");
|
|
let StmtKind::Assign(assign) = stmt.classify() else {
|
|
panic!("expected `Assign` statement, got {stmt:?}");
|
|
};
|
|
|
|
let ranges: Vec<_> = parentheses_iterator(assign.value(), Some(stmt.into()), tokens).collect();
|
|
assert_eq!(ranges.len(), 3);
|
|
assert_eq!(&source[ranges[0]], "(2 + 2)");
|
|
assert_eq!(&source[ranges[1]], "((2 + 2))");
|
|
assert_eq!(&source[ranges[2]], "(((2 + 2)))");
|
|
}
|
|
|
|
#[test]
|
|
fn test_call_arguments_not_counted() {
|
|
let source = "f(x)";
|
|
let parsed = parse_module(source).expect("should parse valid python");
|
|
let tokens = parsed.tokens();
|
|
let module = parsed.syntax();
|
|
|
|
let stmt = module
|
|
.body()
|
|
.first()
|
|
.expect("module should have a statement");
|
|
let StmtKind::Expr(expr_stmt) = stmt.classify() else {
|
|
panic!("expected `Expr` statement, got {stmt:?}");
|
|
};
|
|
|
|
let ExprKind::Call(call) = expr_stmt.value().classify() else {
|
|
panic!("expected Call expression, got {:?}", expr_stmt.value());
|
|
};
|
|
|
|
let arg = call
|
|
.arguments()
|
|
.args()
|
|
.first()
|
|
.expect("call should have an argument");
|
|
let result = parenthesized_range(arg, call.arguments().into(), tokens);
|
|
// The parentheses belong to the call, not the argument
|
|
assert_eq!(result, None);
|
|
}
|
|
|
|
#[test]
|
|
fn test_call_with_parenthesized_argument() {
|
|
let source = "f((x))";
|
|
let parsed = parse_module(source).expect("should parse valid python");
|
|
let tokens = parsed.tokens();
|
|
let module = parsed.syntax();
|
|
|
|
let stmt = module
|
|
.body()
|
|
.first()
|
|
.expect("module should have a statement");
|
|
let StmtKind::Expr(expr_stmt) = stmt.classify() else {
|
|
panic!("expected Expr statement, got {stmt:?}");
|
|
};
|
|
|
|
let ExprKind::Call(call) = expr_stmt.value().classify() else {
|
|
panic!("expected `Call` expression, got {:?}", expr_stmt.value());
|
|
};
|
|
|
|
let arg = call
|
|
.arguments()
|
|
.args()
|
|
.first()
|
|
.expect("call should have an argument");
|
|
let result = parenthesized_range(arg, call.arguments().into(), tokens);
|
|
|
|
let range = result.expect("should find parentheses around argument");
|
|
assert_eq!(&source[range], "(x)");
|
|
}
|
|
|
|
#[test]
|
|
fn multiply_parenthesized_argument() {
|
|
let source = "f(((a + 1)))";
|
|
let parsed = parse_expression(source).expect("valid expression");
|
|
let call = parsed.expr().as_call_expr().expect("call expression");
|
|
let argument = call.arguments().args().first().expect("call argument");
|
|
|
|
let range = parenthesized_range(argument, call.arguments().into(), parsed.tokens())
|
|
.expect("parenthesized argument");
|
|
assert_eq!(&source[range], "((a + 1))");
|
|
}
|
|
|
|
#[test]
|
|
fn parenthesized_tuple_member() {
|
|
let source = "(a, (b))";
|
|
let parsed = parse_expression(source).expect("valid expression");
|
|
let tuple = parsed.expr().as_tuple_expr().expect("tuple expression");
|
|
let member = tuple.elts().last().expect("tuple member");
|
|
|
|
let range = parenthesized_range(member, tuple.into(), parsed.tokens())
|
|
.expect("parenthesized tuple member");
|
|
assert_eq!(&source[range], "(b)");
|
|
}
|
|
|
|
#[test]
|
|
fn tuple_parentheses_do_not_parenthesize_member() {
|
|
let source = "(a, b)";
|
|
let parsed = parse_expression(source).expect("valid expression");
|
|
let tuple = parsed.expr().as_tuple_expr().expect("tuple expression");
|
|
let member = tuple.elts().last().expect("tuple member");
|
|
|
|
assert_eq!(
|
|
parenthesized_range(member, tuple.into(), parsed.tokens()),
|
|
None
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn test_multiline_with_parentheses() {
|
|
let source = "x = (\n 2 + 2 + 2\n)";
|
|
let parsed = parse_module(source).expect("should parse valid python");
|
|
let tokens = parsed.tokens();
|
|
let module = parsed.syntax();
|
|
|
|
let stmt = module
|
|
.body()
|
|
.first()
|
|
.expect("module should have a statement");
|
|
let StmtKind::Assign(assign) = stmt.classify() else {
|
|
panic!("expected `Assign` statement, got {stmt:?}");
|
|
};
|
|
|
|
let result = parenthesized_range(assign.value(), stmt.into(), tokens);
|
|
let range = result.expect("should find parentheses");
|
|
assert_eq!(&source[range], "(\n 2 + 2 + 2\n)");
|
|
}
|