Struct Arguments 

pub struct Arguments {
    pub range: TextRange,
    pub node_index: AtomicNodeIndex,
    pub args: Box<[Expr]>,
    pub keywords: Box<[Keyword]>,
}

An AST node used to represent the arguments passed to a function call or class definition.

For example, given:

foo(1, 2, 3, bar=4, baz=5)

The Arguments node would span from the left to right parentheses (inclusive), and contain the arguments and keyword arguments in the order they appear in the source code.

Similarly, given:

class Foo(Bar, baz=1, qux=2):
    pass

The Arguments node would again span from the left to right parentheses (inclusive), and contain the Bar argument and the baz and qux keyword arguments in the order they appear in the source code.

In the context of a class definition, the Python-style AST refers to the arguments as bases, as they represent the “explicitly specified base classes”, while the keyword arguments are typically used for metaclass, with any additional arguments being passed to the metaclass.

Fields

range: TextRange

node_index: AtomicNodeIndex

args: Box<[Expr]>

keywords: Box<[Keyword]>

Implementations

impl Arguments

pub fn len(&self) -> usize

Return the number of positional and keyword arguments.

pub fn is_empty(&self) -> bool

Return true if there are no positional or keyword arguments.

pub fn find_keyword(&self, keyword_name: &str) -> Option<&Keyword>

Return the Keyword with the given name, or None if no such Keyword exists.

pub fn find_positional(&self, position: usize) -> Option<&Expr>

Return the positional argument at the given index, or None if no such argument exists.

pub fn find_argument_value(&self, name: &str, position: usize) -> Option<&Expr>

Return the value for the argument with the given name or at the given position, or None if no such argument exists. Used to retrieve argument values that can be provided either as keyword or positional arguments.

pub fn find_argument( &self, name: &str, position: usize, ) -> Option<ArgOrKeyword<'_>>

Return the argument with the given name or at the given position, or None if no such argument exists. Used to retrieve arguments that can be provided either as keyword or positional arguments.

pub fn arguments_source_order(&self) -> ArgumentsSourceOrder<'_>

Return the positional and keyword arguments in the order of declaration.

Positional arguments are generally before keyword arguments, but star arguments are an exception:

class A(*args, a=2, *args2, **kwargs):
    pass

f(*args, a=2, *args2, **kwargs)

where *args and args2 are args while a=1 and kwargs are keywords.

If you would just chain args and keywords the call would get reordered which we don’t want. This function instead “merge sorts” them into the correct order.

Note that the order of evaluation is always first args, then keywords:

def f(*args, **kwargs):
    pass

def g(x):
    print(x)
    return x


f(*g([1]), a=g(2), *g([3]), **g({"4": 5}))

Output:

[1]
[3]
2
{'4': 5}

pub fn inner_range(&self) -> TextRange

pub fn l_paren_range(&self) -> TextRange

pub fn r_paren_range(&self) -> TextRange

Trait Implementations

impl Clone for Arguments

fn clone(&self) -> Arguments

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Arguments

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

Formats the value using the given formatter.

impl<'a> From<&'a Arguments> for AnyNodeRef<'a>

fn from(node: &'a Arguments) -> AnyNodeRef<'a>

Converts to this type from the input type.

impl<'a> From<&'a Arguments> for AnyRootNodeRef<'a>

fn from(node: &'a Arguments) -> AnyRootNodeRef<'a>

Converts to this type from the input type.

impl<'a> From<&'a Arguments> for ComparableArguments<'a>

fn from(arguments: &'a Arguments) -> Self

Converts to this type from the input type.

impl HasNodeIndex for Arguments

fn node_index(&self) -> &AtomicNodeIndex

Returns the AtomicNodeIndex for this node.

impl PartialEq for Arguments

fn eq(&self, other: &Arguments) -> 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 Ranged for Arguments

fn range(&self) -> TextRange

The range of this item in the source text.

fn start(&self) -> TextSize

The start offset of this item in the source text.

fn end(&self) -> TextSize

The end offset of this item in the source text.

impl<'a> TryFrom<AnyRootNodeRef<'a>> for &'a Arguments

type Error = ()

The type returned in the event of a conversion error.

fn try_from(node: AnyRootNodeRef<'a>) -> Result<&'a Arguments, ()>

Performs the conversion.

impl StructuralPartialEq for Arguments