Enum geo_aid::script::Error

source ·

pub enum Error {
Show 48 variants    InvalidToken {
        token: Token,
    },
    InvalidCharacter {
        character: char,
        error_span: Span,
    },
    NewLineInString {
        error_span: Span,
    },
    NumberTooLarge {
        error_span: Span,
    },
    SingleVariantExplicitIterator {
        error_span: Span,
    },
    EndOfInput,
    UndefinedRuleOperator {
        operator: NamedIdent,
    },
    InconsistentIterators {
        first_span: Span,
        first_length: usize,
        occurred_span: Span,
        occurred_length: usize,
        error_span: Span,
    },
    IteratorWithSameIdIterator {
        error_span: Span,
        parent_span: Span,
        contained_span: Span,
    },
    InconsistentTypes {
        expected: (Type, Box<Span>),
        got: (Type, Box<Span>),
        error_span: Box<Span>,
    },
    RedefinedVariable {
        defined_at: Span,
        error_span: Span,
        variable_name: String,
    },
    UndefinedTypeVariable {
        definition: Span,
    },
    UndefinedVariable {
        error_span: Span,
        variable_name: String,
        suggested: Option<String>,
    },
    UndefinedFunction {
        error_span: Span,
        function_name: String,
        suggested: Option<String>,
    },
    UndefinedMethod {
        error_span: Span,
        function_name: String,
        suggested: Option<String>,
        on_type: Type,
    },
    UndefinedField {
        error_span: Span,
        field: String,
        on_type: Type,
        suggested: Option<String>,
    },
    NoFieldsOnType {
        error_span: Span,
        on_type: Type,
    },
    FeatureNotSupported {
        error_span: Span,
        feature_name: &'static str,
    },
    InvalidArgumentCount {
        error_span: Span,
        expected: &'static [u8],
        got: u8,
    },
    OverloadNotFound {
        error_span: Span,
        params: Vec<Type>,
        function_name: String,
    },
    CannotUnpack {
        error_span: Span,
        ty: Type,
    },
    ImplicitConversionDoesNotExist {
        error_span: Span,
        from: Type,
        to: Type,
    },
    InvalidOperandType {
        error_span: Box<Span>,
        got: (Type, Box<Span>),
        op: String,
    },
    LetStatUnexpectedIterator {
        var_span: Span,
        error_span: Span,
    },
    LetStatMoreThanOneIterator {
        error_span: Span,
        first_span: Span,
        second_span: Span,
    },
    NonPointInPointCollection {
        error_span: Span,
        received: (Span, Type),
    },
    FlagDoesNotExist {
        flag_name: String,
        flag_span: Span,
        error_span: Span,
        suggested: Option<String>,
    },
    FlagSetExpected {
        error_span: Span,
    },
    StringExpected {
        error_span: Span,
    },
    StringOrIdentExpected {
        error_span: Span,
    },
    NonRawStringOrIdentExpected {
        error_span: Span,
    },
    BooleanExpected {
        error_span: Span,
    },
    NumberExpected {
        error_span: Span,
    },
    InvalidIdentMathString {
        error_span: Span,
    },
    RedefinedFlag {
        error_span: Span,
        first_defined: Span,
        flag_name: String,
    },
    EnumInvalidValue {
        error_span: Span,
        available_values: &'static [&'static str],
        received_value: String,
    },
    RequiredFlagNotSet {
        flag_name: &'static str,
        required_because: Span,
        definition_span: Option<Span>,
        available_values: &'static [&'static str],
    },
    ComparisonDoesNotExist {
        error_span: Span,
        ty: Type,
    },
    EmptyLabel {
        error_span: Span,
    },
    UnclosedSpecial {
        error_span: Span,
        parsed_special: String,
    },
    SpecialNotRecognised {
        error_span: Span,
        code: String,
        suggested: Option<String>,
    },
    UnclosedString {
        error_span: Span,
    },
    LabelIndexInsideIndex {
        error_span: Span,
    },
    UnexpectedDisplayOption {
        error_span: Span,
        option: String,
        suggested: Option<String>,
    },
    RepeatedDisplayOption {
        error_span: Span,
        first_span: Span,
        option: String,
    },
    InvalidPC {
        error_span: Span,
    },
    ZeroDenominator {
        error_span: Span,
    },
    ExpectedFunction {
        error_span: Span,
    },
}