Enum ParseError 

pub enum ParseError {
    UnexpectedEOF(FileId, Vec<String>),
    UnexpectedToken(RawSpan, Vec<String>),
    ExtraToken(RawSpan),
    UnmatchedCloseBrace(RawSpan),
    InvalidEscapeSequence(RawSpan),
    InvalidAsciiEscapeCode(RawSpan),
    StringDelimiterMismatch {
        opening_delimiter: RawSpan,
        closing_delimiter: RawSpan,
    },
    ExternalFormatError(String, String, Option<RawSpan>),
    UnboundTypeVariables(Vec<LocIdent>),
    InvalidRecordType {
        record_span: RawSpan,
        tail_span: Option<RawSpan>,
        cause: InvalidRecordTypeError,
    },
    RecursiveLetPattern(RawSpan),
    PatternInLetBlock(RawSpan),
    TypeVariableKindMismatch {
        ty_var: LocIdent,
        span: RawSpan,
    },
    TypedFieldWithoutDefinition {
        field_span: RawSpan,
        annot_span: RawSpan,
    },
    InterpolationInStaticPath {
        input: String,
        path_elem_span: RawSpan,
    },
    DuplicateIdentInRecordPattern {
        ident: LocIdent,
        prev_ident: LocIdent,
    },
    DuplicateIdentInLetBlock {
        ident: LocIdent,
        prev_ident: LocIdent,
    },
    DisabledFeature {
        feature: String,
        span: RawSpan,
    },
    InvalidContract(RawSpan),
    InvalidImportFormat {
        span: RawSpan,
    },
    SigilExprMissingColon(RawSpan),
    UnknownSigilSelector {
        selector: String,
        span: RawSpan,
    },
    UnknownSigilAttribute {
        selector: String,
        attribute: String,
        span: RawSpan,
    },
    MultipleFieldDecls {
        ident: Ident,
        include_span: RawSpan,
        other_span: RawSpan,
    },
}

An error occurring during parsing.

Variants

UnexpectedEOF(FileId, Vec<String>)

Unexpected end of file.

UnexpectedToken(RawSpan, Vec<String>)

Unexpected token.

ExtraToken(RawSpan)

Superfluous, unexpected token.

UnmatchedCloseBrace(RawSpan)

A closing brace ‘}’ does not match an opening brace ‘{’. This rather precise error is detected because of how interpolated strings are lexed.

InvalidEscapeSequence(RawSpan)

Invalid escape sequence in a string literal.

InvalidAsciiEscapeCode(RawSpan)

Invalid ASCII escape code in a string literal.

StringDelimiterMismatch

A multiline string was closed with a delimiter which has a % count higher than the opening delimiter.

Fields

opening_delimiter: RawSpan

closing_delimiter: RawSpan

ExternalFormatError(String, String, Option<RawSpan>)

Error when parsing an external format such as JSON, YAML, etc.

UnboundTypeVariables(Vec<LocIdent>)

Unbound type variable

InvalidRecordType

Illegal record type literal.

This occurs when failing to convert from the uniterm syntax to a record type literal. See RFC002 for more details.

Fields

record_span: RawSpan

The position of the invalid record.

tail_span: Option<RawSpan>

Position of the tail, if there was one.

cause: InvalidRecordTypeError

The reason that interpretation as a record type failed.

RecursiveLetPattern(RawSpan)

A recursive let pattern was encountered. They are not currently supported because we decided it was too involved to implement them.

PatternInLetBlock(RawSpan)

Let blocks can currently only contain plain bindings, not pattern bindings.

TypeVariableKindMismatch

A type variable is used in ways that imply it has muiltiple different kinds.

This can happen in several situations, for example:

• a variable is used as both a type variable and a row type variable, e.g. in the signature forall r. { ; r } -> r,
• a variable is used as both a record and enum row variable, e.g. in the signature forall r. [| ; r |] -> { ; r }.

Fields

ty_var: LocIdent

span: RawSpan

TypedFieldWithoutDefinition

A record literal, which isn’t a record type, has a field with a type annotation but without a definition. While we could technically handle this situation, this is most probably an error from the user, because this type annotation is useless and, maybe non-intuitively, won’t have any effect as part of a larger contract:

let MixedContract = {foo : String, bar | Number} in
{ foo = 1, bar = 2} | MixedContract

This example works, because the foo : String annotation doesn’t propagate, and contract application is mostly merging, which is probably not the intent. It might become a warning in a future version, but we don’t have warnings for now, so we rather forbid such constructions.

Fields

field_span: RawSpan

The position of the field definition.

annot_span: RawSpan

The position of the type annotation.

InterpolationInStaticPath

The user provided a field path on the CLI, which is expected to be only composed of literals, but the parsed field path contains string interpolation.

Fields

input: String

path_elem_span: RawSpan

DuplicateIdentInRecordPattern

A duplicate binding was encountered in a record destructuring pattern.

Fields

ident: LocIdent

The duplicate identifier.

prev_ident: LocIdent

The previous instance of the duplicated identifier.

DuplicateIdentInLetBlock

A duplicate binding was encountered in a let block.

Fields

ident: LocIdent

The duplicate identifier.

prev_ident: LocIdent

The previous instance of the duplicated identifier.

DisabledFeature

There was an attempt to use a feature that hasn’t been enabled.

Fields

feature: String

span: RawSpan

InvalidContract(RawSpan)

A term was used as a contract in type position, but this term has no chance to make any sense as a contract. What terms make sense might evolve with time, but any given point in time, there are a set of expressions that can be excluded syntactically. Currently, it’s mostly constants.

InvalidImportFormat

Unrecognized explicit import format tag

Fields

span: RawSpan

SigilExprMissingColon(RawSpan)

A CLI sigil expression such as @env:FOO is invalid because no : separator was found.

UnknownSigilSelector

A CLI sigil expression is unknown or unsupported, such as @unknown:value.

Fields

selector: String

span: RawSpan

UnknownSigilAttribute

A CLI sigil attribute is unknown or unsupported, such as @file/unsupported:value.

Fields

selector: String

attribute: String

span: RawSpan

MultipleFieldDecls

An included field has several definitions. While we could just merge both at runtime like a piecewise field definition, we entirely forbid this situation for now.

Fields

ident: Ident

The identifier.

include_span: RawSpan

The identifier and the position of the include expression. The ident part is the same as the ident part of ident.

other_span: RawSpan

The span of the other declaration, which can be either a field definition or an include expression as well.

Implementations

impl ParseError

pub fn from_lalrpop<T>( error: ParseError<usize, T, InternalParseError>, file_id: FileId, ) -> ParseError

pub fn from_serde_json(error: Error, file_id: FileId, files: &Files) -> Self

pub fn from_yaml(error: ScanError, file_id: Option<FileId>) -> Self

pub fn from_toml(error: TomlError, file_id: FileId) -> Self

Trait Implementations

impl Clone for ParseError

fn clone(&self) -> ParseError

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for ParseError

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

Formats the value using the given formatter.

impl From<ParseError> for Error

fn from(error: ParseError) -> Error

Converts to this type from the input type.

impl From<ParseError> for ParseErrors

fn from(e: ParseError) -> ParseErrors

Converts to this type from the input type.

impl From<UnboundTypeVariableError> for ParseError

fn from(err: UnboundTypeVariableError) -> Self

Converts to this type from the input type.

impl IntoDiagnostics for ParseError

fn into_diagnostics(self, files: &mut Files) -> Vec<Diagnostic<FileId>>

Convert an error to a list of printable formatted diagnostic.

impl PartialEq for ParseError

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

impl StructuralPartialEq for ParseError