Struct ParseModuleResult 

pub struct ParseModuleResult {
    pub module: Module,
    pub diagnostics: Vec<ParseDiagnostic>,
}

Result of tolerant module parsing.

The parser always returns a Module, even when it had to recover from lexical errors, malformed syntax, unsupported syntax, or skipped declarations. Inspect Self::diagnostics (or use Self::has_errors) to decide whether the partial tree is acceptable. Use Self::into_result for callers that require a diagnostic-free parse.

Fields

module: Module

Parsed module tree. This is always present and may be partial when diagnostics were recorded.

diagnostics: Vec<ParseDiagnostic>

Recoverable parse and lex issues in source order.

Implementations

impl ParseModuleResult

pub const fn has_errors(&self) -> bool

True when tolerant parsing recorded any recoverable diagnostic.

pub fn into_parts(self) -> (Module, Vec<ParseDiagnostic>)

Split the partial module tree from its source-ordered diagnostics.

pub fn into_result(self) -> Result<Module, ParseModuleError>

Convert a tolerant parse result into a strict Result.

Returns Ok only when Self::diagnostics is empty. Any diagnostic — lexical, malformed, skipped declaration, unsupported syntax, or recursion-limit degradation — becomes Err.

Errors

Returns ParseModuleError when Self::diagnostics is non-empty.

use daml_parser::parse::parse_module;

let ok = parse_module("module M where\nfoo: Int\nfoo = 1\n").into_result();
assert!(ok.is_ok());

let err = parse_module("module M where\n@@@\n").into_result();
assert!(err.is_err());
assert!(!err.unwrap_err().diagnostics().is_empty());

Trait Implementations

impl Clone for ParseModuleResult

fn clone(&self) -> ParseModuleResult

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for ParseModuleResult

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

Formats the value using the given formatter.

impl Eq for ParseModuleResult

impl PartialEq for ParseModuleResult

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