Files
Micha Reiser 043802b0d8 Build typed arena nodes in the Python parser
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.
2026-11-20 16:16:30 +00:00

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)");
}