Struct nu_protocol::ast::Call

pub struct Call {
    pub decl_id: DeclId,
    pub head: Span,
    pub arguments: Vec<Argument>,
    pub parser_info: HashMap<String, Expression>,
}

Fields

decl_id: DeclId

identifier of the declaration to call

head: Span

arguments: Vec<Argument>

parser_info: HashMap<String, Expression>

this field is used by the parser to pass additional command-specific information

Implementations

impl Call

pub fn new(head: Span) -> Call

pub fn arguments_span(&self) -> Span

The span encompassing the arguments

If there are no arguments the span covers where the first argument would exist

If there are one or more arguments the span encompasses the start of the first argument to end of the last argument

pub fn named_iter( &self ) -> impl Iterator<Item = &(Spanned<String>, Option<Spanned<String>>, Option<Expression>)>

pub fn named_iter_mut( &mut self ) -> impl Iterator<Item = &mut (Spanned<String>, Option<Spanned<String>>, Option<Expression>)>

pub fn named_len(&self) -> usize

pub fn add_named( &mut self, named: (Spanned<String>, Option<Spanned<String>>, Option<Expression>) )

pub fn add_positional(&mut self, positional: Expression)

pub fn add_unknown(&mut self, unknown: Expression)

pub fn add_spread(&mut self, args: Expression)

pub fn positional_iter(&self) -> impl Iterator<Item = &Expression>

pub fn positional_iter_mut(&mut self) -> impl Iterator<Item = &mut Expression>

pub fn positional_nth(&self, i: usize) -> Option<&Expression>

pub fn positional_nth_mut(&mut self, i: usize) -> Option<&mut Expression>

pub fn positional_len(&self) -> usize

pub fn rest_iter( &self, start: usize ) -> impl Iterator<Item = (&Expression, bool)>

Returns every argument to the rest parameter, as well as whether each argument is spread or a normal positional argument (true for spread, false for normal)

pub fn get_parser_info(&self, name: &str) -> Option<&Expression>

pub fn set_parser_info( &mut self, name: String, val: Expression ) -> Option<Expression>

pub fn get_flag_expr(&self, flag_name: &str) -> Option<&Expression>

pub fn get_named_arg(&self, flag_name: &str) -> Option<Spanned<String>>

pub fn has_flag_const( &self, working_set: &StateWorkingSet<'_>, flag_name: &str ) -> Result<bool, ShellError>

Check if a boolean flag is set (i.e. --bool or --bool=true) evaluating the expression after = as a constant command

pub fn get_flag_const<T: FromValue>( &self, working_set: &StateWorkingSet<'_>, name: &str ) -> Result<Option<T>, ShellError>

pub fn rest_const<T: FromValue>( &self, working_set: &StateWorkingSet<'_>, starting_pos: usize ) -> Result<Vec<T>, ShellError>

pub fn rest_iter_flattened<F>( &self, start: usize, eval: F ) -> Result<Vec<Value>, ShellError>

where F: FnMut(&Expression) -> Result<Value, ShellError>,

pub fn req_const<T: FromValue>( &self, working_set: &StateWorkingSet<'_>, pos: usize ) -> Result<T, ShellError>

pub fn span(&self) -> Span

Trait Implementations

impl Clone for Call

fn clone(&self) -> Call

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Call

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Call

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl PartialEq for Call

fn eq(&self, other: &Call) -> bool

This method tests for self and other values to be equal, and is used by ==.

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

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

impl Serialize for Call

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for Call