Struct Error 

pub struct Error { /* private fields */ }

Why a sketch could not be forged into a Language, or a capability pipeline could not be assembled.

Forging checks the whole sketch and reports every problem it finds, not just the first, so one round of fixes is usually enough. Each problem is a Diagnostic with a Code (LSF and four digits, LSF2 §27) and a label that points into the sketch. For a single document handed to Language::from_lsf the spans are byte offsets into that text: add it to a fresh SourceMap and the spans line up. For a Sketch of several files they are positions in the sketch’s own source_map. Either way Renderer draws each problem under the line at fault.

Display prints the first problem as line:column: message (with the file’s path in front for a multi-file sketch), which is enough for a log line or a test failure; render the diagnostics for the full picture.

What to do with one

An Error always means the sketch needs editing: forging is deterministic, so retrying the same text fails the same way. Every message names what was found and what was expected, and many carry a help line with the fix.

Examples

use lang_forge::Language;
use lang_forge::diag_lang::{Renderer, SourceMap};

let schematic = r#"
[language]
name = "broken"

[rules]
program = "stmt*"
stmt    = "exprr ';'"
expr    = "NUMBER"
"#;

let err = Language::from_lsf(schematic).unwrap_err();
assert_eq!(err.to_string(), "7:12: undefined rule `exprr`");
assert_eq!(err.diagnostics().len(), 1);
assert_eq!(err.diagnostics()[0].code().map(|c| c.to_string()).as_deref(), Some("LSF4101"));

// Render it with source context.
let mut map = SourceMap::new();
map.add("broken.lsf", schematic).expect("fits");
let text = Renderer::new().render(&err.diagnostics()[0], &map);
assert!(text.contains("help: did you mean `expr`?"));

Implementations

impl Error

pub fn diagnostics(&self) -> &[Diagnostic]

Every problem found, in the order they appear in the sketch.

Never empty. Spans are byte offsets into the sketch text (positions in the sketch’s source map for a multi-file Sketch).

Examples

use lang_forge::Language;

let err = Language::from_lsf("[language]\n[rules]\n").unwrap_err();
let messages: Vec<&str> = err.diagnostics().iter().map(|d| d.message()).collect();
assert_eq!(messages, ["missing `name` in [language]", "[rules] declares no rules"]);

Trait Implementations

impl Clone for Error

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Error

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

Formats the value using the given formatter.

impl Display for Error

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

Formats the value using the given formatter.

impl Eq for Error

impl Error for Error

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

Returns 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.

impl PartialEq for Error

fn eq(&self, other: &Self) -> bool

Equality operator ==.

fn ne(&self, other: &Rhs) -> bool

Inequality operator !=.

impl StructuralPartialEq for Error