language-servers/ruff
1
0
Fork 0
mirror of https://github.com/astral-sh/ruff.git synced 2025-08-19 01:51:30 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions 3

Rename Arguments to Parameters in the AST (#6253)

Browse source 
## Summary

This PR renames a few AST nodes for clarity:

- `Arguments` is now `Parameters`
- `Arg` is now `Parameter`
- `ArgWithDefault` is now `ParameterWithDefault`

For now, the attribute names that reference `Parameters` directly are
changed (e.g., on `StmtFunctionDef`), but the attributes on `Parameters`
itself are not (e.g., `vararg`). We may revisit that decision in the
future.

For context, the AST node formerly known as `Arguments` is used in
function definitions. Formally (outside of the Python context),
"arguments" typically refers to "the values passed to a function", while
"parameters" typically refers to "the variables used in a function
definition". E.g., if you Google "arguments vs parameters", you'll get
some explanation like:

> A parameter is a variable in a function definition. It is a
placeholder and hence does not have a concrete value. An argument is a
value passed during function invocation.

We're thus deviating from Python's nomenclature in favor of a scheme
that we find to be more precise.
This commit is contained in:
Charlie Marsh 2023-08-01 13:53:28 -04:00 • committed by GitHub
parent a82eb9544c
commit adc8bb7821
No known key found for this signature in database
GPG key ID: 4AEE18F83AFDEB23
102 changed files with 2585 additions and 2529 deletions
Download patch file Download diff file Expand all files Collapse all files

68
crates/ruff_python_ast/src/comparable.rs
View file

@ -340,46 +340,46 @@ impl<'a> From<&'a ast::Constant> for ComparableConstant<'a> {
}
#[derive(Debug, PartialEq, Eq, Hash)]
pub struct ComparableArguments<'a> {
posonlyargs: Vec<ComparableArgWithDefault<'a>>,
args: Vec<ComparableArgWithDefault<'a>>,
vararg: Option<ComparableArg<'a>>,
kwonlyargs: Vec<ComparableArgWithDefault<'a>>,
kwarg: Option<ComparableArg<'a>>,
pub struct ComparableParameters<'a> {
posonlyargs: Vec<ComparableParameterWithDefault<'a>>,
args: Vec<ComparableParameterWithDefault<'a>>,
vararg: Option<ComparableParameter<'a>>,
kwonlyargs: Vec<ComparableParameterWithDefault<'a>>,
kwarg: Option<ComparableParameter<'a>>,
}
impl<'a> From<&'a ast::Arguments> for ComparableArguments<'a> {
fn from(arguments: &'a ast::Arguments) -> Self {
impl<'a> From<&'a ast::Parameters> for ComparableParameters<'a> {
fn from(parameters: &'a ast::Parameters) -> Self {
Self {
posonlyargs: arguments.posonlyargs.iter().map(Into::into).collect(),
args: arguments.args.iter().map(Into::into).collect(),
vararg: arguments.vararg.as_ref().map(Into::into),
kwonlyargs: arguments.kwonlyargs.iter().map(Into::into).collect(),
kwarg: arguments.kwarg.as_ref().map(Into::into),
posonlyargs: parameters.posonlyargs.iter().map(Into::into).collect(),
args: parameters.args.iter().map(Into::into).collect(),
vararg: parameters.vararg.as_ref().map(Into::into),
kwonlyargs: parameters.kwonlyargs.iter().map(Into::into).collect(),
kwarg: parameters.kwarg.as_ref().map(Into::into),
}
}
}
impl<'a> From<&'a Box<ast::Arguments>> for ComparableArguments<'a> {
fn from(arguments: &'a Box<ast::Arguments>) -> Self {
(arguments.as_ref()).into()
impl<'a> From<&'a Box<ast::Parameters>> for ComparableParameters<'a> {
fn from(parameters: &'a Box<ast::Parameters>) -> Self {
(parameters.as_ref()).into()
}
}
impl<'a> From<&'a Box<ast::Arg>> for ComparableArg<'a> {
fn from(arg: &'a Box<ast::Arg>) -> Self {
impl<'a> From<&'a Box<ast::Parameter>> for ComparableParameter<'a> {
fn from(arg: &'a Box<ast::Parameter>) -> Self {
(arg.as_ref()).into()
}
}
#[derive(Debug, PartialEq, Eq, Hash)]
pub struct ComparableArg<'a> {
pub struct ComparableParameter<'a> {
arg: &'a str,
annotation: Option<Box<ComparableExpr<'a>>>,
}
impl<'a> From<&'a ast::Arg> for ComparableArg<'a> {
fn from(arg: &'a ast::Arg) -> Self {
impl<'a> From<&'a ast::Parameter> for ComparableParameter<'a> {
fn from(arg: &'a ast::Parameter) -> Self {
Self {
arg: arg.arg.as_str(),
annotation: arg.annotation.as_ref().map(Into::into),
@ -388,13 +388,13 @@ impl<'a> From<&'a ast::Arg> for ComparableArg<'a> {
}
#[derive(Debug, PartialEq, Eq, Hash)]
pub struct ComparableArgWithDefault<'a> {
def: ComparableArg<'a>,
pub struct ComparableParameterWithDefault<'a> {
def: ComparableParameter<'a>,
default: Option<ComparableExpr<'a>>,
}
impl<'a> From<&'a ast::ArgWithDefault> for ComparableArgWithDefault<'a> {
fn from(arg: &'a ast::ArgWithDefault) -> Self {
impl<'a> From<&'a ast::ParameterWithDefault> for ComparableParameterWithDefault<'a> {
fn from(arg: &'a ast::ParameterWithDefault) -> Self {
Self {
def: (&arg.def).into(),
default: arg.default.as_ref().map(Into::into),
@ -511,7 +511,7 @@ pub struct ExprUnaryOp<'a> {
#[derive(Debug, PartialEq, Eq, Hash)]
pub struct ExprLambda<'a> {
args: ComparableArguments<'a>,
parameters: ComparableParameters<'a>,
body: Box<ComparableExpr<'a>>,
}
@ -739,11 +739,11 @@ impl<'a> From<&'a ast::Expr> for ComparableExpr<'a> {
operand: operand.into(),
}),
ast::Expr::Lambda(ast::ExprLambda {
args,
parameters,
body,
range: _range,
}) => Self::Lambda(ExprLambda {
args: (args.as_ref()).into(),
parameters: (parameters.as_ref()).into(),
body: body.into(),
}),
ast::Expr::IfExp(ast::ExprIfExp {
@ -948,7 +948,7 @@ impl<'a> From<&'a ast::Expr> for ComparableExpr<'a> {
#[derive(Debug, PartialEq, Eq, Hash)]
pub struct StmtFunctionDef<'a> {
name: &'a str,
args: ComparableArguments<'a>,
parameters: ComparableParameters<'a>,
body: Vec<ComparableStmt<'a>>,
decorator_list: Vec<ComparableDecorator<'a>>,
type_params: Vec<ComparableTypeParam<'a>>,
@ -958,7 +958,7 @@ pub struct StmtFunctionDef<'a> {
#[derive(Debug, PartialEq, Eq, Hash)]
pub struct StmtAsyncFunctionDef<'a> {
name: &'a str,
args: ComparableArguments<'a>,
parameters: ComparableParameters<'a>,
body: Vec<ComparableStmt<'a>>,
decorator_list: Vec<ComparableDecorator<'a>>,
type_params: Vec<ComparableTypeParam<'a>>,
@ -1208,7 +1208,7 @@ impl<'a> From<&'a ast::Stmt> for ComparableStmt<'a> {
match stmt {
ast::Stmt::FunctionDef(ast::StmtFunctionDef {
name,
args,
parameters,
body,
decorator_list,
returns,
@ -1216,7 +1216,7 @@ impl<'a> From<&'a ast::Stmt> for ComparableStmt<'a> {
range: _range,
}) => Self::FunctionDef(StmtFunctionDef {
name: name.as_str(),
args: args.into(),
parameters: parameters.into(),
body: body.iter().map(Into::into).collect(),
decorator_list: decorator_list.iter().map(Into::into).collect(),
returns: returns.as_ref().map(Into::into),
@ -1224,7 +1224,7 @@ impl<'a> From<&'a ast::Stmt> for ComparableStmt<'a> {
}),
ast::Stmt::AsyncFunctionDef(ast::StmtAsyncFunctionDef {
name,
args,
parameters,
body,
decorator_list,
returns,
@ -1232,7 +1232,7 @@ impl<'a> From<&'a ast::Stmt> for ComparableStmt<'a> {
range: _range,
}) => Self::AsyncFunctionDef(StmtAsyncFunctionDef {
name: name.as_str(),
args: args.into(),
parameters: parameters.into(),
body: body.iter().map(Into::into).collect(),
decorator_list: decorator_list.iter().map(Into::into).collect(),
returns: returns.as_ref().map(Into::into),

8
crates/ruff_python_ast/src/function.rs
View file

@ -1,6 +1,6 @@
use crate::node::AnyNodeRef;
use crate::{
Arguments, Decorator, Expr, Identifier, Ranged, StmtAsyncFunctionDef, StmtFunctionDef, Suite,
Decorator, Expr, Identifier, Parameters, Ranged, StmtAsyncFunctionDef, StmtFunctionDef, Suite,
};
use ruff_text_size::TextRange;
@ -49,10 +49,10 @@ impl<'a> AnyFunctionDefinition<'a> {
}
/// Returns the function arguments (parameters).
pub fn arguments(self) -> &'a Arguments {
pub fn arguments(self) -> &'a Parameters {
match self {
Self::FunctionDefinition(definition) => definition.args.as_ref(),
Self::AsyncFunctionDefinition(definition) => definition.args.as_ref(),
Self::FunctionDefinition(definition) => definition.parameters.as_ref(),
Self::AsyncFunctionDefinition(definition) => definition.parameters.as_ref(),
}
}

41
crates/ruff_python_ast/src/helpers.rs
View file

@ -2,7 +2,7 @@ use std::borrow::Cow;
use std::path::Path;
use crate::{
self as ast, Arguments, Constant, ExceptHandler, Expr, Keyword, MatchCase, Pattern, Ranged,
self as ast, Constant, ExceptHandler, Expr, Keyword, MatchCase, Parameters, Pattern, Ranged,
Stmt, TypeParam,
};
use num_traits::Zero;
@ -347,40 +347,43 @@ where
{
match stmt {
Stmt::FunctionDef(ast::StmtFunctionDef {
args,
parameters,
body,
decorator_list,
returns,
..
})
| Stmt::AsyncFunctionDef(ast::StmtAsyncFunctionDef {
args,
parameters,
body,
decorator_list,
returns,
..
}) => {
args.posonlyargs
parameters
.posonlyargs
.iter()
.chain(args.args.iter().chain(args.kwonlyargs.iter()))
.any(|arg_with_default| {
arg_with_default
.chain(parameters.args.iter().chain(parameters.kwonlyargs.iter()))
.any(|parameter| {
parameter
.default
.as_ref()
.is_some_and(|expr| any_over_expr(expr, func))
|| arg_with_default
|| parameter
.def
.annotation
.as_ref()
.is_some_and(|expr| any_over_expr(expr, func))
})
|| args.vararg.as_ref().is_some_and(|arg| {
arg.annotation
|| parameters.vararg.as_ref().is_some_and(|parameter| {
parameter
.annotation
.as_ref()
.is_some_and(|expr| any_over_expr(expr, func))
})
|| args.kwarg.as_ref().is_some_and(|arg| {
arg.annotation
|| parameters.kwarg.as_ref().is_some_and(|parameter| {
parameter
.annotation
.as_ref()
.is_some_and(|expr| any_over_expr(expr, func))
})
@ -709,23 +712,23 @@ pub fn extract_handled_exceptions(handlers: &[ExceptHandler]) -> Vec<&Expr> {
handled_exceptions
}
/// Returns `true` if the given name is included in the given [`Arguments`].
pub fn includes_arg_name(name: &str, arguments: &Arguments) -> bool {
if arguments
/// Returns `true` if the given name is included in the given [`Parameters`].
pub fn includes_arg_name(name: &str, parameters: &Parameters) -> bool {
if parameters
.posonlyargs
.iter()
.chain(&arguments.args)
.chain(&arguments.kwonlyargs)
.chain(&parameters.args)
.chain(&parameters.kwonlyargs)
.any(|arg| arg.def.arg.as_str() == name)
{
return true;
}
if let Some(arg) = &arguments.vararg {
if let Some(arg) = &parameters.vararg {
if arg.arg.as_str() == name {
return true;
}
}
if let Some(arg) = &arguments.kwarg {
if let Some(arg) = &parameters.kwarg {
if arg.arg.as_str() == name {
return true;
}

10
crates/ruff_python_ast/src/identifier.rs
View file

@ -10,7 +10,7 @@
//!
//! This module can be used to identify the [`TextRange`] of the `except` token.
use crate::{self as ast, Alias, Arg, ArgWithDefault, ExceptHandler, Ranged, Stmt};
use crate::{self as ast, Alias, ExceptHandler, Parameter, ParameterWithDefault, Ranged, Stmt};
use ruff_text_size::{TextLen, TextRange, TextSize};
use ruff_python_trivia::{is_python_whitespace, Cursor};
@ -38,8 +38,8 @@ impl Identifier for Stmt {
}
}
impl Identifier for Arg {
/// Return the [`TextRange`] for the identifier defining an [`Arg`].
impl Identifier for Parameter {
/// Return the [`TextRange`] for the identifier defining an [`Parameter`].
///
/// For example, return the range of `x` in:
/// ```python
@ -51,8 +51,8 @@ impl Identifier for Arg {
}
}
impl Identifier for ArgWithDefault {
/// Return the [`TextRange`] for the identifier defining an [`ArgWithDefault`].
impl Identifier for ParameterWithDefault {
/// Return the [`TextRange`] for the identifier defining an [`ParameterWithDefault`].
///
/// For example, return the range of `x` in:
/// ```python

168
crates/ruff_python_ast/src/node.rs
View file

@ -1,7 +1,7 @@
use crate::{
self as ast, Alias, Arg, ArgWithDefault, Arguments, Comprehension, Decorator, ExceptHandler,
Expr, Keyword, MatchCase, Mod, Pattern, Ranged, Stmt, TypeParam, TypeParamParamSpec,
TypeParamTypeVar, TypeParamTypeVarTuple, WithItem,
self as ast, Alias, Comprehension, Decorator, ExceptHandler, Expr, Keyword, MatchCase, Mod,
Parameter, ParameterWithDefault, Parameters, Pattern, Ranged, Stmt, TypeParam,
TypeParamParamSpec, TypeParamTypeVar, TypeParamTypeVarTuple, WithItem,
};
use ruff_text_size::TextRange;
use std::ptr::NonNull;
@ -90,9 +90,9 @@ pub enum AnyNode {
PatternMatchAs(ast::PatternMatchAs),
PatternMatchOr(ast::PatternMatchOr),
Comprehension(Comprehension),
Arguments(Arguments),
Arg(Arg),
ArgWithDefault(ArgWithDefault),
Parameters(Parameters),
Parameter(Parameter),
ParameterWithDefault(ParameterWithDefault),
Keyword(Keyword),
Alias(Alias),
WithItem(WithItem),
@ -177,9 +177,9 @@ impl AnyNode {
| AnyNode::PatternMatchAs(_)
| AnyNode::PatternMatchOr(_)
| AnyNode::Comprehension(_)
| AnyNode::Arguments(_)
| AnyNode::Arg(_)
| AnyNode::ArgWithDefault(_)
| AnyNode::Parameters(_)
| AnyNode::Parameter(_)
| AnyNode::ParameterWithDefault(_)
| AnyNode::Keyword(_)
| AnyNode::Alias(_)
| AnyNode::WithItem(_)
@ -264,9 +264,9 @@ impl AnyNode {
| AnyNode::PatternMatchAs(_)
| AnyNode::PatternMatchOr(_)
| AnyNode::Comprehension(_)
| AnyNode::Arguments(_)
| AnyNode::Arg(_)
| AnyNode::ArgWithDefault(_)
| AnyNode::Parameters(_)
| AnyNode::Parameter(_)
| AnyNode::ParameterWithDefault(_)
| AnyNode::Keyword(_)
| AnyNode::Alias(_)
| AnyNode::WithItem(_)
@ -351,9 +351,9 @@ impl AnyNode {
| AnyNode::PatternMatchAs(_)
| AnyNode::PatternMatchOr(_)
| AnyNode::Comprehension(_)
| AnyNode::Arguments(_)
| AnyNode::Arg(_)
| AnyNode::ArgWithDefault(_)
| AnyNode::Parameters(_)
| AnyNode::Parameter(_)
| AnyNode::ParameterWithDefault(_)
| AnyNode::Keyword(_)
| AnyNode::Alias(_)
| AnyNode::WithItem(_)
@ -438,9 +438,9 @@ impl AnyNode {
| AnyNode::ExprLineMagic(_)
| AnyNode::ExceptHandlerExceptHandler(_)
| AnyNode::Comprehension(_)
| AnyNode::Arguments(_)
| AnyNode::Arg(_)
| AnyNode::ArgWithDefault(_)
| AnyNode::Parameters(_)
| AnyNode::Parameter(_)
| AnyNode::ParameterWithDefault(_)
| AnyNode::Keyword(_)
| AnyNode::Alias(_)
| AnyNode::WithItem(_)
@ -525,9 +525,9 @@ impl AnyNode {
| AnyNode::PatternMatchAs(_)
| AnyNode::PatternMatchOr(_)
| AnyNode::Comprehension(_)
| AnyNode::Arguments(_)
| AnyNode::Arg(_)
| AnyNode::ArgWithDefault(_)
| AnyNode::Parameters(_)
| AnyNode::Parameter(_)
| AnyNode::ParameterWithDefault(_)
| AnyNode::Keyword(_)
| AnyNode::Alias(_)
| AnyNode::WithItem(_)
@ -631,9 +631,9 @@ impl AnyNode {
Self::PatternMatchAs(node) => AnyNodeRef::PatternMatchAs(node),
Self::PatternMatchOr(node) => AnyNodeRef::PatternMatchOr(node),
Self::Comprehension(node) => AnyNodeRef::Comprehension(node),
Self::Arguments(node) => AnyNodeRef::Arguments(node),
Self::Arg(node) => AnyNodeRef::Arg(node),
Self::ArgWithDefault(node) => AnyNodeRef::ArgWithDefault(node),
Self::Parameters(node) => AnyNodeRef::Parameters(node),
Self::Parameter(node) => AnyNodeRef::Parameter(node),
Self::ParameterWithDefault(node) => AnyNodeRef::ParameterWithDefault(node),
Self::Keyword(node) => AnyNodeRef::Keyword(node),
Self::Alias(node) => AnyNodeRef::Alias(node),
Self::WithItem(node) => AnyNodeRef::WithItem(node),
@ -2613,12 +2613,12 @@ impl AstNode for Comprehension {
AnyNode::from(self)
}
}
impl AstNode for Arguments {
impl AstNode for Parameters {
fn cast(kind: AnyNode) -> Option<Self>
where
Self: Sized,
{
if let AnyNode::Arguments(node) = kind {
if let AnyNode::Parameters(node) = kind {
Some(node)
} else {
None
@ -2626,7 +2626,7 @@ impl AstNode for Arguments {
}
fn cast_ref(kind: AnyNodeRef) -> Option<&Self> {
if let AnyNodeRef::Arguments(node) = kind {
if let AnyNodeRef::Parameters(node) = kind {
Some(node)
} else {
None
@ -2641,12 +2641,12 @@ impl AstNode for Arguments {
AnyNode::from(self)
}
}
impl AstNode for Arg {
impl AstNode for Parameter {
fn cast(kind: AnyNode) -> Option<Self>
where
Self: Sized,
{
if let AnyNode::Arg(node) = kind {
if let AnyNode::Parameter(node) = kind {
Some(node)
} else {
None
@ -2654,7 +2654,7 @@ impl AstNode for Arg {
}
fn cast_ref(kind: AnyNodeRef) -> Option<&Self> {
if let AnyNodeRef::Arg(node) = kind {
if let AnyNodeRef::Parameter(node) = kind {
Some(node)
} else {
None
@ -2669,12 +2669,12 @@ impl AstNode for Arg {
AnyNode::from(self)
}
}
impl AstNode for ArgWithDefault {
impl AstNode for ParameterWithDefault {
fn cast(kind: AnyNode) -> Option<Self>
where
Self: Sized,
{
if let AnyNode::ArgWithDefault(node) = kind {
if let AnyNode::ParameterWithDefault(node) = kind {
Some(node)
} else {
None
@ -2682,7 +2682,7 @@ impl AstNode for ArgWithDefault {
}
fn cast_ref(kind: AnyNodeRef) -> Option<&Self> {
if let AnyNodeRef::ArgWithDefault(node) = kind {
if let AnyNodeRef::ParameterWithDefault(node) = kind {
Some(node)
} else {
None
@ -3444,19 +3444,19 @@ impl From<Comprehension> for AnyNode {
AnyNode::Comprehension(node)
}
}
impl From<Arguments> for AnyNode {
fn from(node: Arguments) -> Self {
AnyNode::Arguments(node)
impl From<Parameters> for AnyNode {
fn from(node: Parameters) -> Self {
AnyNode::Parameters(node)
}
}
impl From<Arg> for AnyNode {
fn from(node: Arg) -> Self {
AnyNode::Arg(node)
impl From<Parameter> for AnyNode {
fn from(node: Parameter) -> Self {
AnyNode::Parameter(node)
}
}
impl From<ArgWithDefault> for AnyNode {
fn from(node: ArgWithDefault) -> Self {
AnyNode::ArgWithDefault(node)
impl From<ParameterWithDefault> for AnyNode {
fn from(node: ParameterWithDefault) -> Self {
AnyNode::ParameterWithDefault(node)
}
}
impl From<Keyword> for AnyNode {
@ -3574,9 +3574,9 @@ impl Ranged for AnyNode {
AnyNode::PatternMatchAs(node) => node.range(),
AnyNode::PatternMatchOr(node) => node.range(),
AnyNode::Comprehension(node) => node.range(),
AnyNode::Arguments(node) => node.range(),
AnyNode::Arg(node) => node.range(),
AnyNode::ArgWithDefault(node) => node.range(),
AnyNode::Parameters(node) => node.range(),
AnyNode::Parameter(node) => node.range(),
AnyNode::ParameterWithDefault(node) => node.range(),
AnyNode::Keyword(node) => node.range(),
AnyNode::Alias(node) => node.range(),
AnyNode::WithItem(node) => node.range(),
@ -3661,9 +3661,9 @@ pub enum AnyNodeRef<'a> {
PatternMatchAs(&'a ast::PatternMatchAs),
PatternMatchOr(&'a ast::PatternMatchOr),
Comprehension(&'a Comprehension),
Arguments(&'a Arguments),
Arg(&'a Arg),
ArgWithDefault(&'a ArgWithDefault),
Parameters(&'a Parameters),
Parameter(&'a Parameter),
ParameterWithDefault(&'a ParameterWithDefault),
Keyword(&'a Keyword),
Alias(&'a Alias),
WithItem(&'a WithItem),
@ -3747,9 +3747,9 @@ impl AnyNodeRef<'_> {
AnyNodeRef::PatternMatchAs(node) => NonNull::from(*node).cast(),
AnyNodeRef::PatternMatchOr(node) => NonNull::from(*node).cast(),
AnyNodeRef::Comprehension(node) => NonNull::from(*node).cast(),
AnyNodeRef::Arguments(node) => NonNull::from(*node).cast(),
AnyNodeRef::Arg(node) => NonNull::from(*node).cast(),
AnyNodeRef::ArgWithDefault(node) => NonNull::from(*node).cast(),
AnyNodeRef::Parameters(node) => NonNull::from(*node).cast(),
AnyNodeRef::Parameter(node) => NonNull::from(*node).cast(),
AnyNodeRef::ParameterWithDefault(node) => NonNull::from(*node).cast(),
AnyNodeRef::Keyword(node) => NonNull::from(*node).cast(),
AnyNodeRef::Alias(node) => NonNull::from(*node).cast(),
AnyNodeRef::WithItem(node) => NonNull::from(*node).cast(),
@ -3839,9 +3839,9 @@ impl AnyNodeRef<'_> {
AnyNodeRef::PatternMatchAs(_) => NodeKind::PatternMatchAs,
AnyNodeRef::PatternMatchOr(_) => NodeKind::PatternMatchOr,
AnyNodeRef::Comprehension(_) => NodeKind::Comprehension,
AnyNodeRef::Arguments(_) => NodeKind::Arguments,
AnyNodeRef::Arg(_) => NodeKind::Arg,
AnyNodeRef::ArgWithDefault(_) => NodeKind::ArgWithDefault,
AnyNodeRef::Parameters(_) => NodeKind::Parameters,
AnyNodeRef::Parameter(_) => NodeKind::Parameter,
AnyNodeRef::ParameterWithDefault(_) => NodeKind::ParameterWithDefault,
AnyNodeRef::Keyword(_) => NodeKind::Keyword,
AnyNodeRef::Alias(_) => NodeKind::Alias,
AnyNodeRef::WithItem(_) => NodeKind::WithItem,
@ -3926,9 +3926,9 @@ impl AnyNodeRef<'_> {
| AnyNodeRef::PatternMatchAs(_)
| AnyNodeRef::PatternMatchOr(_)
| AnyNodeRef::Comprehension(_)
| AnyNodeRef::Arguments(_)
| AnyNodeRef::Arg(_)
| AnyNodeRef::ArgWithDefault(_)
| AnyNodeRef::Parameters(_)
| AnyNodeRef::Parameter(_)
| AnyNodeRef::ParameterWithDefault(_)
| AnyNodeRef::Keyword(_)
| AnyNodeRef::Alias(_)
| AnyNodeRef::WithItem(_)
@ -4013,9 +4013,9 @@ impl AnyNodeRef<'_> {
| AnyNodeRef::PatternMatchAs(_)
| AnyNodeRef::PatternMatchOr(_)
| AnyNodeRef::Comprehension(_)
| AnyNodeRef::Arguments(_)
| AnyNodeRef::Arg(_)
| AnyNodeRef::ArgWithDefault(_)
| AnyNodeRef::Parameters(_)
| AnyNodeRef::Parameter(_)
| AnyNodeRef::ParameterWithDefault(_)
| AnyNodeRef::Keyword(_)
| AnyNodeRef::Alias(_)
| AnyNodeRef::WithItem(_)
@ -4099,9 +4099,9 @@ impl AnyNodeRef<'_> {
| AnyNodeRef::PatternMatchAs(_)
| AnyNodeRef::PatternMatchOr(_)
| AnyNodeRef::Comprehension(_)
| AnyNodeRef::Arguments(_)
| AnyNodeRef::Arg(_)
| AnyNodeRef::ArgWithDefault(_)
| AnyNodeRef::Parameters(_)
| AnyNodeRef::Parameter(_)
| AnyNodeRef::ParameterWithDefault(_)
| AnyNodeRef::Keyword(_)
| AnyNodeRef::Alias(_)
| AnyNodeRef::WithItem(_)
@ -4186,9 +4186,9 @@ impl AnyNodeRef<'_> {
| AnyNodeRef::ExprLineMagic(_)
| AnyNodeRef::ExceptHandlerExceptHandler(_)
| AnyNodeRef::Comprehension(_)
| AnyNodeRef::Arguments(_)
| AnyNodeRef::Arg(_)
| AnyNodeRef::ArgWithDefault(_)
| AnyNodeRef::Parameters(_)
| AnyNodeRef::Parameter(_)
| AnyNodeRef::ParameterWithDefault(_)
| AnyNodeRef::Keyword(_)
| AnyNodeRef::Alias(_)
| AnyNodeRef::WithItem(_)
@ -4273,9 +4273,9 @@ impl AnyNodeRef<'_> {
| AnyNodeRef::PatternMatchAs(_)
| AnyNodeRef::PatternMatchOr(_)
| AnyNodeRef::Comprehension(_)
| AnyNodeRef::Arguments(_)
| AnyNodeRef::Arg(_)
| AnyNodeRef::ArgWithDefault(_)
| AnyNodeRef::Parameters(_)
| AnyNodeRef::Parameter(_)
| AnyNodeRef::ParameterWithDefault(_)
| AnyNodeRef::Keyword(_)
| AnyNodeRef::Alias(_)
| AnyNodeRef::WithItem(_)
@ -4877,19 +4877,19 @@ impl<'a> From<&'a Comprehension> for AnyNodeRef<'a> {
AnyNodeRef::Comprehension(node)
}
}
impl<'a> From<&'a Arguments> for AnyNodeRef<'a> {
fn from(node: &'a Arguments) -> Self {
AnyNodeRef::Arguments(node)
impl<'a> From<&'a Parameters> for AnyNodeRef<'a> {
fn from(node: &'a Parameters) -> Self {
AnyNodeRef::Parameters(node)
}
}
impl<'a> From<&'a Arg> for AnyNodeRef<'a> {
fn from(node: &'a Arg) -> Self {
AnyNodeRef::Arg(node)
impl<'a> From<&'a Parameter> for AnyNodeRef<'a> {
fn from(node: &'a Parameter) -> Self {
AnyNodeRef::Parameter(node)
}
}
impl<'a> From<&'a ArgWithDefault> for AnyNodeRef<'a> {
fn from(node: &'a ArgWithDefault) -> Self {
AnyNodeRef::ArgWithDefault(node)
impl<'a> From<&'a ParameterWithDefault> for AnyNodeRef<'a> {
fn from(node: &'a ParameterWithDefault) -> Self {
AnyNodeRef::ParameterWithDefault(node)
}
}
impl<'a> From<&'a Keyword> for AnyNodeRef<'a> {
@ -4985,9 +4985,9 @@ impl Ranged for AnyNodeRef<'_> {
AnyNodeRef::PatternMatchAs(node) => node.range(),
AnyNodeRef::PatternMatchOr(node) => node.range(),
AnyNodeRef::Comprehension(node) => node.range(),
AnyNodeRef::Arguments(node) => node.range(),
AnyNodeRef::Arg(node) => node.range(),
AnyNodeRef::ArgWithDefault(node) => node.range(),
AnyNodeRef::Parameters(node) => node.range(),
AnyNodeRef::Parameter(node) => node.range(),
AnyNodeRef::ParameterWithDefault(node) => node.range(),
AnyNodeRef::Keyword(node) => node.range(),
AnyNodeRef::Alias(node) => node.range(),
AnyNodeRef::WithItem(node) => node.range(),
@ -5075,9 +5075,9 @@ pub enum NodeKind {
PatternMatchOr,
TypeIgnoreTypeIgnore,
Comprehension,
Arguments,
Arg,
ArgWithDefault,
Parameters,
Parameter,
ParameterWithDefault,
Keyword,
Alias,
WithItem,

78
crates/ruff_python_ast/src/nodes.rs
View file

@ -122,7 +122,7 @@ impl From<StmtLineMagic> for Stmt {
pub struct StmtFunctionDef {
pub range: TextRange,
pub name: Identifier,
pub args: Box<Arguments>,
pub parameters: Box<Parameters>,
pub body: Vec<Stmt>,
pub decorator_list: Vec<Decorator>,
pub returns: Option<Box<Expr>>,
@ -140,7 +140,7 @@ impl From<StmtFunctionDef> for Stmt {
pub struct StmtAsyncFunctionDef {
pub range: TextRange,
pub name: Identifier,
pub args: Box<Arguments>,
pub parameters: Box<Parameters>,
pub body: Vec<Stmt>,
pub decorator_list: Vec<Decorator>,
pub returns: Option<Box<Expr>>,
@ -668,7 +668,7 @@ impl From<ExprUnaryOp> for Expr {
#[derive(Clone, Debug, PartialEq)]
pub struct ExprLambda {
pub range: TextRange,
pub args: Box<Arguments>,
pub parameters: Box<Parameters>,
pub body: Box<Expr>,
}
@ -1822,22 +1822,9 @@ impl From<ExceptHandlerExceptHandler> for ExceptHandler {
}
}
/// See also [arguments](https://docs.python.org/3/library/ast.html#ast.arguments)
#[derive(Clone, Debug, PartialEq)]
pub struct PythonArguments {
pub range: TextRange,
pub posonlyargs: Vec<Arg>,
pub args: Vec<Arg>,
pub vararg: Option<Box<Arg>>,
pub kwonlyargs: Vec<Arg>,
pub kw_defaults: Vec<Expr>,
pub kwarg: Option<Box<Arg>>,
pub defaults: Vec<Expr>,
}
/// See also [arg](https://docs.python.org/3/library/ast.html#ast.arg)
#[derive(Clone, Debug, PartialEq)]
pub struct Arg {
pub struct Parameter {
pub range: TextRange,
pub arg: Identifier,
pub annotation: Option<Box<Expr>>,
@ -2056,22 +2043,22 @@ pub struct Decorator {
/// An alternative type of AST `arguments`. This is ruff_python_parser-friendly and human-friendly definition of function arguments.
/// This form also has advantage to implement pre-order traverse.
/// `defaults` and `kw_defaults` fields are removed and the default values are placed under each `arg_with_default` typed argument.
///
/// `defaults` and `kw_defaults` fields are removed and the default values are placed under each [`ParameterWithDefault`] typed argument.
/// `vararg` and `kwarg` are still typed as `arg` because they never can have a default value.
///
/// The matching Python style AST type is [`PythonArguments`]. While [`PythonArguments`] has ordered `kwonlyargs` fields by
/// default existence, [Arguments] has location-ordered kwonlyargs fields.
/// The original Python-style AST type orders `kwonlyargs` fields by default existence; [Parameters] has location-ordered `kwonlyargs` fields.
///
/// NOTE: This type is different from original Python AST.
/// NOTE: This type differs from the original Python AST. See: [arguments](https://docs.python.org/3/library/ast.html#ast.arguments).
#[derive(Clone, Debug, PartialEq)]
pub struct Arguments {
pub struct Parameters {
pub range: TextRange,
pub posonlyargs: Vec<ArgWithDefault>,
pub args: Vec<ArgWithDefault>,
pub vararg: Option<Box<Arg>>,
pub kwonlyargs: Vec<ArgWithDefault>,
pub kwarg: Option<Box<Arg>>,
pub posonlyargs: Vec<ParameterWithDefault>,
pub args: Vec<ParameterWithDefault>,
pub vararg: Option<Box<Parameter>>,
pub kwonlyargs: Vec<ParameterWithDefault>,
pub kwarg: Option<Box<Parameter>>,
}
/// An alternative type of AST `arg`. This is used for each function argument that might have a default value.
@ -2080,9 +2067,9 @@ pub struct Arguments {
/// NOTE: This type is different from original Python AST.
#[derive(Clone, Debug, PartialEq)]
pub struct ArgWithDefault {
pub struct ParameterWithDefault {
pub range: TextRange,
pub def: Arg,
pub def: Parameter,
pub default: Option<Box<Expr>>,
}
@ -2105,7 +2092,7 @@ impl CmpOp {
}
}
impl Arguments {
impl Parameters {
pub fn empty(range: TextRange) -> Self {
Self {
range,
@ -2124,21 +2111,21 @@ fn clone_boxed_expr(expr: &Box<Expr>) -> Box<Expr> {
Box::new(expr.clone())
}
impl ArgWithDefault {
pub fn as_arg(&self) -> &Arg {
impl ParameterWithDefault {
pub fn as_parameter(&self) -> &Parameter {
&self.def
}
pub fn to_arg(&self) -> (Arg, Option<Box<Expr>>) {
let ArgWithDefault {
pub fn to_parameter(&self) -> (Parameter, Option<Box<Expr>>) {
let ParameterWithDefault {
range: _,
def,
default,
} = self;
(def.clone(), default.as_ref().map(clone_boxed_expr))
}
pub fn into_arg(self) -> (Arg, Option<Box<Expr>>) {
let ArgWithDefault {
pub fn into_parameter(self) -> (Parameter, Option<Box<Expr>>) {
let ParameterWithDefault {
range: _,
def,
default,
@ -2147,7 +2134,7 @@ impl ArgWithDefault {
}
}
impl Arguments {
impl Parameters {
pub fn defaults(&self) -> impl std::iter::Iterator<Item = &Expr> {
self.posonlyargs
.iter()
@ -2156,14 +2143,14 @@ impl Arguments {
}
#[allow(clippy::type_complexity)]
pub fn split_kwonlyargs(&self) -> (Vec<&Arg>, Vec<(&Arg, &Expr)>) {
pub fn split_kwonlyargs(&self) -> (Vec<&Parameter>, Vec<(&Parameter, &Expr)>) {
let mut args = Vec::new();
let mut with_defaults = Vec::new();
for arg in &self.kwonlyargs {
if let Some(ref default) = arg.default {
with_defaults.push((arg.as_arg(), &**default));
with_defaults.push((arg.as_parameter(), &**default));
} else {
args.push(arg.as_arg());
args.push(arg.as_parameter());
}
}
(args, with_defaults)
@ -2838,12 +2825,7 @@ impl Ranged for crate::ExceptHandler {
}
}
impl Ranged for crate::nodes::PythonArguments {
fn range(&self) -> TextRange {
self.range
}
}
impl Ranged for crate::nodes::Arg {
impl Ranged for crate::nodes::Parameter {
fn range(&self) -> TextRange {
self.range
}
@ -2952,12 +2934,12 @@ impl Ranged for crate::nodes::Decorator {
self.range
}
}
impl Ranged for crate::nodes::Arguments {
impl Ranged for crate::nodes::Parameters {
fn range(&self) -> TextRange {
self.range
}
}
impl Ranged for crate::nodes::ArgWithDefault {
impl Ranged for crate::nodes::ParameterWithDefault {
fn range(&self) -> TextRange {
self.range
}

58
crates/ruff_python_ast/src/visitor.rs
View file

@ -3,9 +3,9 @@
pub mod preorder;
use crate::{
self as ast, Alias, Arg, Arguments, BoolOp, CmpOp, Comprehension, Decorator, ElifElseClause,
ExceptHandler, Expr, ExprContext, Keyword, MatchCase, Operator, Pattern, Stmt, TypeParam,
TypeParamTypeVar, UnaryOp, WithItem,
self as ast, Alias, BoolOp, CmpOp, Comprehension, Decorator, ElifElseClause, ExceptHandler,
Expr, ExprContext, Keyword, MatchCase, Operator, Parameter, Parameters, Pattern, Stmt,
TypeParam, TypeParamTypeVar, UnaryOp, WithItem,
};
/// A trait for AST visitors. Visits all nodes in the AST recursively in evaluation-order.
@ -52,11 +52,11 @@ pub trait Visitor<'a> {
fn visit_format_spec(&mut self, format_spec: &'a Expr) {
walk_format_spec(self, format_spec);
}
fn visit_arguments(&mut self, arguments: &'a Arguments) {
walk_arguments(self, arguments);
fn visit_parameters(&mut self, parameters: &'a Parameters) {
walk_parameters(self, parameters);
}
fn visit_arg(&mut self, arg: &'a Arg) {
walk_arg(self, arg);
fn visit_parameter(&mut self, parameter: &'a Parameter) {
walk_parameter(self, parameter);
}
fn visit_keyword(&mut self, keyword: &'a Keyword) {
walk_keyword(self, keyword);
@ -103,7 +103,7 @@ pub fn walk_elif_else_clause<'a, V: Visitor<'a> + ?Sized>(
pub fn walk_stmt<'a, V: Visitor<'a> + ?Sized>(visitor: &mut V, stmt: &'a Stmt) {
match stmt {
Stmt::FunctionDef(ast::StmtFunctionDef {
args,
parameters,
body,
decorator_list,
returns,
@ -116,14 +116,14 @@ pub fn walk_stmt<'a, V: Visitor<'a> + ?Sized>(visitor: &mut V, stmt: &'a Stmt) {
for type_param in type_params {
visitor.visit_type_param(type_param);
}
visitor.visit_arguments(args);
visitor.visit_parameters(parameters);
for expr in returns {
visitor.visit_annotation(expr);
}
visitor.visit_body(body);
}
Stmt::AsyncFunctionDef(ast::StmtAsyncFunctionDef {
args,
parameters,
body,
decorator_list,
returns,
@ -136,7 +136,7 @@ pub fn walk_stmt<'a, V: Visitor<'a> + ?Sized>(visitor: &mut V, stmt: &'a Stmt) {
for type_param in type_params {
visitor.visit_type_param(type_param);
}
visitor.visit_arguments(args);
visitor.visit_parameters(parameters);
for expr in returns {
visitor.visit_annotation(expr);
}
@ -411,11 +411,11 @@ pub fn walk_expr<'a, V: Visitor<'a> + ?Sized>(visitor: &mut V, expr: &'a Expr) {
visitor.visit_expr(operand);
}
Expr::Lambda(ast::ExprLambda {
args,
parameters,
body,
range: _range,
}) => {
visitor.visit_arguments(args);
visitor.visit_parameters(parameters);
visitor.visit_expr(body);
}
Expr::IfExp(ast::ExprIfExp {
@ -645,43 +645,43 @@ pub fn walk_format_spec<'a, V: Visitor<'a> + ?Sized>(visitor: &mut V, format_spe
visitor.visit_expr(format_spec);
}
pub fn walk_arguments<'a, V: Visitor<'a> + ?Sized>(visitor: &mut V, arguments: &'a Arguments) {
pub fn walk_parameters<'a, V: Visitor<'a> + ?Sized>(visitor: &mut V, parameters: &'a Parameters) {
// Defaults are evaluated before annotations.
for arg in &arguments.posonlyargs {
for arg in &parameters.posonlyargs {
if let Some(default) = &arg.default {
visitor.visit_expr(default);
}
}
for arg in &arguments.args {
for arg in &parameters.args {
if let Some(default) = &arg.default {
visitor.visit_expr(default);
}
}
for arg in &arguments.kwonlyargs {
for arg in &parameters.kwonlyargs {
if let Some(default) = &arg.default {
visitor.visit_expr(default);
}
}
for arg in &arguments.posonlyargs {
visitor.visit_arg(&arg.def);
for arg in &parameters.posonlyargs {
visitor.visit_parameter(&arg.def);
}
for arg in &arguments.args {
visitor.visit_arg(&arg.def);
for arg in &parameters.args {
visitor.visit_parameter(&arg.def);
}
if let Some(arg) = &arguments.vararg {
visitor.visit_arg(arg);
if let Some(arg) = &parameters.vararg {
visitor.visit_parameter(arg);
}
for arg in &arguments.kwonlyargs {
visitor.visit_arg(&arg.def);
for arg in &parameters.kwonlyargs {
visitor.visit_parameter(&arg.def);
}
if let Some(arg) = &arguments.kwarg {
visitor.visit_arg(arg);
if let Some(arg) = &parameters.kwarg {
visitor.visit_parameter(arg);
}
}
pub fn walk_arg<'a, V: Visitor<'a> + ?Sized>(visitor: &mut V, arg: &'a Arg) {
if let Some(expr) = &arg.annotation {
pub fn walk_parameter<'a, V: Visitor<'a> + ?Sized>(visitor: &mut V, parameter: &'a Parameter) {
if let Some(expr) = &parameter.annotation {
visitor.visit_annotation(expr);
}
}

60
crates/ruff_python_ast/src/visitor/preorder.rs
View file

@ -1,7 +1,7 @@
use crate::{
self as ast, Alias, Arg, ArgWithDefault, Arguments, BoolOp, CmpOp, Comprehension, Constant,
Decorator, ElifElseClause, ExceptHandler, Expr, Keyword, MatchCase, Mod, Operator, Pattern,
Stmt, TypeParam, TypeParamTypeVar, UnaryOp, WithItem,
self as ast, Alias, BoolOp, CmpOp, Comprehension, Constant, Decorator, ElifElseClause,
ExceptHandler, Expr, Keyword, MatchCase, Mod, Operator, Parameter, ParameterWithDefault,
Parameters, Pattern, Stmt, TypeParam, TypeParamTypeVar, UnaryOp, WithItem,
};
/// Visitor that traverses all nodes recursively in pre-order.
@ -56,16 +56,16 @@ pub trait PreorderVisitor<'a> {
walk_format_spec(self, format_spec);
}
fn visit_arguments(&mut self, arguments: &'a Arguments) {
walk_arguments(self, arguments);
fn visit_parameters(&mut self, parameters: &'a Parameters) {
walk_parameters(self, parameters);
}
fn visit_arg(&mut self, arg: &'a Arg) {
walk_arg(self, arg);
fn visit_parameter(&mut self, arg: &'a Parameter) {
walk_parameter(self, arg);
}
fn visit_arg_with_default(&mut self, arg_with_default: &'a ArgWithDefault) {
walk_arg_with_default(self, arg_with_default);
fn visit_parameter_with_default(&mut self, parameter_with_default: &'a ParameterWithDefault) {
walk_parameter_with_default(self, parameter_with_default);
}
fn visit_keyword(&mut self, keyword: &'a Keyword) {
@ -133,7 +133,7 @@ where
}) => visitor.visit_expr(value),
Stmt::FunctionDef(ast::StmtFunctionDef {
args,
parameters,
body,
decorator_list,
returns,
@ -141,7 +141,7 @@ where
..
})
| Stmt::AsyncFunctionDef(ast::StmtAsyncFunctionDef {
args,
parameters,
body,
decorator_list,
returns,
@ -156,7 +156,7 @@ where
visitor.visit_type_param(type_param);
}
visitor.visit_arguments(args);
visitor.visit_parameters(parameters);
for expr in returns {
visitor.visit_annotation(expr);
@ -469,11 +469,11 @@ where
}
Expr::Lambda(ast::ExprLambda {
args,
parameters,
body,
range: _range,
}) => {
visitor.visit_arguments(args);
visitor.visit_parameters(parameters);
visitor.visit_expr(body);
}
@ -749,42 +749,44 @@ pub fn walk_format_spec<'a, V: PreorderVisitor<'a> + ?Sized>(
visitor.visit_expr(format_spec);
}
pub fn walk_arguments<'a, V>(visitor: &mut V, arguments: &'a Arguments)
pub fn walk_parameters<'a, V>(visitor: &mut V, parameters: &'a Parameters)
where
V: PreorderVisitor<'a> + ?Sized,
{
for arg in arguments.posonlyargs.iter().chain(&arguments.args) {
visitor.visit_arg_with_default(arg);
for arg in parameters.posonlyargs.iter().chain(&parameters.args) {
visitor.visit_parameter_with_default(arg);
}
if let Some(arg) = &arguments.vararg {
visitor.visit_arg(arg);
if let Some(arg) = &parameters.vararg {
visitor.visit_parameter(arg);
}
for arg in &arguments.kwonlyargs {
visitor.visit_arg_with_default(arg);
for arg in &parameters.kwonlyargs {
visitor.visit_parameter_with_default(arg);
}
if let Some(arg) = &arguments.kwarg {
visitor.visit_arg(arg);
if let Some(arg) = &parameters.kwarg {
visitor.visit_parameter(arg);
}
}
pub fn walk_arg<'a, V>(visitor: &mut V, arg: &'a Arg)
pub fn walk_parameter<'a, V>(visitor: &mut V, parameter: &'a Parameter)
where
V: PreorderVisitor<'a> + ?Sized,
{
if let Some(expr) = &arg.annotation {
if let Some(expr) = &parameter.annotation {
visitor.visit_annotation(expr);
}
}
pub fn walk_arg_with_default<'a, V>(visitor: &mut V, arg_with_default: &'a ArgWithDefault)
where
pub fn walk_parameter_with_default<'a, V>(
visitor: &mut V,
parameter_with_default: &'a ParameterWithDefault,
) where
V: PreorderVisitor<'a> + ?Sized,
{
visitor.visit_arg(&arg_with_default.def);
if let Some(expr) = &arg_with_default.default {
visitor.visit_parameter(&parameter_with_default.def);
if let Some(expr) = &parameter_with_default.default {
visitor.visit_expr(expr);
}
}