Enum boxworks_lang::Error

pub enum Error<'a> {
    PositionalArgAfterKeywordArg {
        positional_arg: Str<'a>,
        keyword_arg: Str<'a>,
    },
    IncorrectType {
        wanted_type: &'static str,
        got_type: &'static str,
        got_raw_value: Str<'a>,
        function_name: Str<'a>,
        parameter_name: &'a str,
    },
    TooManyPositionalArgs {
        extra_positional_arg: Str<'a>,
        function_name: Str<'a>,
        max_positional_args: usize,
    },
    NoSuchArgument {
        function_name: Str<'a>,
        argument: Str<'a>,
    },
    DuplicateArgument {
        parameter_name: &'a str,
        first_assignment: Str<'a>,
        second_assignment: Str<'a>,
    },
    NoSuchFunction {
        function_name: Str<'a>,
    },
    UnmatchedOpeningBracket {
        open: Str<'a>,
    },
    UnmatchedClosingBracket {
        close: Str<'a>,
    },
    InvalidDimensionUnit {
        dimension: Str<'a>,
        unit: Str<'a>,
    },
    UnexpectedToken {
        want: &'static str,
        got: Str<'a>,
        skipped: Str<'a>,
    },
    MissingArgsForFunction {
        function_name: Str<'a>,
    },
    MismatchedBraces {
        open: Str<'a>,
        close: Str<'a>,
    },
    IncompleteKeywordArg {
        keyword: Str<'a>,
    },
    MultipleDecimalPoints {
        point: Str<'a>,
    },
    NumberWithoutUnits {
        number: Str<'a>,
    },
    InvalidCharacter {
        char: Str<'a>,
    },
}

Error encountered when parsing Box language.

Variants

PositionalArgAfterKeywordArg

A positional argument appears after a keyword argument.

This is an error, just like in Python. The problem is that it’s ambiguous which parameter the positional argument should apply to.

Fields

positional_arg: Str<'a>

keyword_arg: Str<'a>

IncorrectType

A function argument has the wrong type.

Fields

wanted_type: &'static str

got_type: &'static str

got_raw_value: Str<'a>

function_name: Str<'a>

parameter_name: &'a str

TooManyPositionalArgs

Too many positional arguments provided.

Fields

extra_positional_arg: Str<'a>

function_name: Str<'a>

max_positional_args: usize

NoSuchArgument

No such argument to this function.

Fields

function_name: Str<'a>

argument: Str<'a>

DuplicateArgument

The same argument was provided multiple times.

Fields

parameter_name: &'a str

first_assignment: Str<'a>

second_assignment: Str<'a>

NoSuchFunction

The specified function does not exist.

Fields

function_name: Str<'a>

UnmatchedOpeningBracket

An opening bracket token ‘[’ or ‘(’ was unmatched.

Fields

open: Str<'a>

UnmatchedClosingBracket

A closing bracket token ‘]’ or ‘)’ was unmatched.

Fields

close: Str<'a>

InvalidDimensionUnit

An invalid unit was provided for a dimension.

Fields

dimension: Str<'a>

unit: Str<'a>

UnexpectedToken

An unexpected token was encountered.

Fields

want: &'static str

got: Str<'a>

skipped: Str<'a>

MissingArgsForFunction

A function name appeared without any arguments

Fields

function_name: Str<'a>

MismatchedBraces

Mismatched braces - e.g. [) or (].

Fields

open: Str<'a>

close: Str<'a>

IncompleteKeywordArg

Input ended while parsing a function keyword argument

Fields

keyword: Str<'a>

MultipleDecimalPoints

A number has multiple decimal points.

Fields

point: Str<'a>

NumberWithoutUnits

No units were specified for a number.

Fields

number: Str<'a>

InvalidCharacter

Input contains an invalid character (like a non-ASCII character)

Fields

char: Str<'a>

Implementations

impl<'a> Error<'a>

pub fn message(&self) -> String

pub fn labels(&self) -> Vec<ErrorLabel>

pub fn notes(&self) -> Vec<String>

impl<'a> Error<'a>

pub fn ariadne_report( &self, file_name: &'a str, ) -> Report<'static, (&str, Range<usize>)>

Trait Implementations

impl<'a> Debug for Error<'a>

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

Formats the value using the given formatter.

impl<'a> PartialEq for Error<'a>

fn eq(&self, other: &Error<'a>) -> 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<'a> Eq for Error<'a>

impl<'a> StructuralPartialEq for Error<'a>