Struct rustpython_ast::Arguments

pub struct Arguments<R = TextRange> {
    pub range: OptionalRange<R>,
    pub posonlyargs: Vec<ArgWithDefault<R>>,
    pub args: Vec<ArgWithDefault<R>>,
    pub vararg: Option<Box<Arg<R>>>,
    pub kwonlyargs: Vec<ArgWithDefault<R>>,
    pub kwarg: Option<Box<Arg<R>>>,
}

An alternative type of AST arguments. This is 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. 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.

NOTE: This type is different from original Python AST.

Fields

range: OptionalRange<R>

posonlyargs: Vec<ArgWithDefault<R>>

args: Vec<ArgWithDefault<R>>

vararg: Option<Box<Arg<R>>>

kwonlyargs: Vec<ArgWithDefault<R>>

kwarg: Option<Box<Arg<R>>>

Implementations

impl<R> Arguments<R>

pub fn empty(range: OptionalRange<R>) -> Self

impl<R> Arguments<R>

pub fn defaults(&self) -> impl Iterator<Item = &Expr<R>>

pub fn split_kwonlyargs(&self) -> (Vec<&Arg<R>>, Vec<(&Arg<R>, &Expr<R>)>)

pub fn to_python_arguments(&self) -> PythonArguments<R>

where R: Clone,

pub fn into_python_arguments(self) -> PythonArguments<R>

Trait Implementations

impl<R: Clone> Clone for Arguments<R>

fn clone(&self) -> Arguments<R>

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<R: Debug> Debug for Arguments<R>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<T, U> Foldable<T, U> for Arguments<T>

type Mapped = Arguments<U>

fn fold<F: Fold<T, TargetU = U> + ?Sized>( self, folder: &mut F, ) -> Result<Self::Mapped, F::Error>

impl<R> From<Arguments<R>> for Ast<R>

fn from(node: Arguments<R>) -> Self

Converts to this type from the input type.

impl<R> From<Arguments<R>> for PythonArguments<R>

fn from(arguments: Arguments<R>) -> Self

Converts to this type from the input type.

impl<R> Node for Arguments<R>

const NAME: &'static str = "alt:arguments"

const FIELD_NAMES: &'static [&'static str] = _

impl<R: PartialEq> PartialEq for Arguments<R>

fn eq(&self, other: &Arguments<R>) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<R> StructuralPartialEq for Arguments<R>