Enum arithmetic_typing::ast::AstConversionError

#[non_exhaustive]
pub enum AstConversionError {
    EmbeddedQuantifier,
    FreeLengthVar(String),
    FreeTypeVar(String),
    UnusedLength(String),
    UnusedTypeParam(String),
    UnknownType(String),
    UnknownConstraint(String),
    InvalidSomeType,
    InvalidSomeLength,
    DuplicateField(String),
    NotObjectSafe(String),
}

Kinds of errors that can occur when converting *Ast types into their “main” counterparts.

During type inference, errors of this type are wrapped into the AstConversion variant of typing errors.

Examples

use arithmetic_parser::grammars::{Parse, F32Grammar};
use arithmetic_typing::{
    ast::AstConversionError, error::ErrorKind, Annotated, TypeEnvironment,
};

let code = "bogus_slice: ['T; _] = (1, 2, 3);";
let ast = Annotated::<F32Grammar>::parse_statements(code)?;

let errors = TypeEnvironment::new().process_statements(&ast).unwrap_err();
let err = errors.into_iter().next().unwrap();
assert_eq!(err.main_location().span(code), "'T");
assert_matches!(
    err.kind(),
    ErrorKind::AstConversion(AstConversionError::FreeTypeVar(id))
        if id == "T"
);

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.

EmbeddedQuantifier

Embedded param quantifiers.

FreeLengthVar(String)

Length param not scoped by a function.

FreeTypeVar(String)

Type param not scoped by a function.

UnusedLength(String)

Unused length param.

UnusedTypeParam(String)

Unused length param.

UnknownType(String)

Unknown type name.

UnknownConstraint(String)

Unknown constraint.

InvalidSomeType

Some type (_) encountered when parsing a standalone type.

_ types are only allowed in the context of a TypeEnvironment. It is a logical error to use them when parsing standalone types.

InvalidSomeLength

Some length (_) encountered when parsing a standalone type.

_ lengths are only allowed in the context of a TypeEnvironment. It is a logical error to use them when parsing standalone types.

DuplicateField(String)

Field with the same name is defined multiple times in an object type.

NotObjectSafe(String)

Constraint is not object-safe.

Trait Implementations

impl Clone for AstConversionError

fn clone(&self) -> AstConversionError

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for AstConversionError

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

Formats the value using the given formatter.

impl Display for AstConversionError

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

Formats the value using the given formatter.

impl Error for AstConversionError

fn source(&self) -> Option<&(dyn Error + 'static)>

The lower-level source of this error, if any.

fn description(&self) -> &str

👎Deprecated since 1.42.0: use the Display impl or to_string()

fn cause(&self) -> Option<&dyn Error>

👎Deprecated since 1.33.0: replaced by Error::source, which can support downcasting

fn provide<'a>(&'a self, request: &mut Request<'a>)

🔬This is a nightly-only experimental API. (error_generic_member_access)

Provides type based access to context intended for error reports.