Enum ArgsErrorKind 

#[non_exhaustive]
pub enum ArgsErrorKind {
    HelpRequested {
        help_text: String,
    },
    UnexpectedPositionalArgument {
        fields: &'static [Field],
    },
    NoFields {
        shape: &'static Shape,
    },
    EnumWithoutSubcommandAttribute {
        field: &'static Field,
    },
    UnknownLongFlag {
        flag: String,
        fields: &'static [Field],
    },
    UnknownShortFlag {
        flag: String,
        fields: &'static [Field],
        precise_span: Option<Span>,
    },
    MissingArgument {
        field: &'static Field,
    },
    ExpectedValueGotEof {
        shape: &'static Shape,
    },
    UnknownSubcommand {
        provided: String,
        variants: &'static [Variant],
    },
    MissingSubcommand {
        variants: &'static [Variant],
    },
    ReflectError(ReflectError),
}

An error kind for argument parsing.

Stores references to static shape/field/variant info for lazy formatting.

Variants (Non-exhaustive)

Non-exhaustive enums could have additional variants added in future. Therefore, when matching against variants of non-exhaustive enums, an extra wildcard arm must be added to account for any future variants.

HelpRequested

Help was requested via -h, –help, -help, or /?

This is not really an “error” but uses the error path to return help text when the user explicitly requests it.

Fields

help_text: String

The generated help text

UnexpectedPositionalArgument

Did not expect a positional argument at this position

Fields

fields: &'static [Field]

Fields of the struct/variant being parsed (for help text)

NoFields

Wanted to look up a field, for example --something in a struct, but the current shape was not a struct.

Fields

shape: &'static Shape

The shape that was being parsed

EnumWithoutSubcommandAttribute

Found an enum field without the args::subcommand attribute. Enums can only be used as subcommands when explicitly marked.

Fields

field: &'static Field

The field that has the enum type

UnknownLongFlag

Passed --something (see span), no such long flag

Fields

flag: String

The flag that was passed

fields: &'static [Field]

Fields of the struct/variant being parsed

UnknownShortFlag

Passed -j (see span), no such short flag

Fields

flag: String

The flag that was passed

fields: &'static [Field]

Fields of the struct/variant being parsed

precise_span: Option<Span>

Precise span for the invalid flag (used for chained short flags like -axc where x is invalid)

MissingArgument

Struct/type expected a certain argument to be passed and it wasn’t

Fields

field: &'static Field

The field that was missing

ExpectedValueGotEof

Expected a value of type shape, got EOF

Fields

shape: &'static Shape

The type that was expected

UnknownSubcommand

Unknown subcommand name

Fields

provided: String

The subcommand that was provided

variants: &'static [Variant]

Variants of the enum (subcommands)

MissingSubcommand

Required subcommand was not provided

Fields

variants: &'static [Variant]

Variants of the enum (available subcommands)

ReflectError(ReflectError)

Generic reflection error: something went wrong

Implementations

impl ArgsErrorKind

pub fn precise_span(&self) -> Option<Span>

Returns a precise span override if the error kind has one. This is used for errors like UnknownShortFlag in chained flags where we want to highlight just the invalid character, not the whole arg.

pub fn code(&self) -> &'static str

Returns an error code for this error kind.

pub fn label(&self) -> String

Returns a short label for the error (shown inline in the source)

pub fn help(&self) -> Option<Box<dyn Display + '_>>

Returns help text for this error

pub fn is_help_request(&self) -> bool

Returns true if this is a help request (not a real error)

pub fn help_text(&self) -> Option<&str>

If this is a help request, returns the help text

Trait Implementations

impl Clone for ArgsErrorKind

fn clone(&self) -> ArgsErrorKind

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for ArgsErrorKind

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

Formats the value using the given formatter.

impl Display for ArgsErrorKind

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

Formats the value using the given formatter.

impl From<ReflectError> for ArgsErrorKind

fn from(error: ReflectError) -> Self

Converts to this type from the input type.