xidlc 0.41.0

A IDL codegen.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82

#![allow(unused_assignments)]

use miette::{Diagnostic, LabeledSpan, NamedSource, SourceSpan};
use thiserror::Error;

#[derive(Debug, Error)]
pub enum IdlcError {
    #[error(transparent)]
    Io(#[from] std::io::Error),
    #[error(transparent)]
    Parse(#[from] xidl_parser::error::ParseError),
    #[error(transparent)]
    Json(#[from] serde_json::Error),
    #[error("{0}")]
    Template(String),
    #[error("{0}")]
    Rpc(String),
    #[error("{0}")]
    Fmt(String),
    #[error("{0}")]
    Diagnostics(#[from] DiagnosticListError),
}

#[derive(Debug, Error)]
#[error("{} diagnostics found", diagnostics.len())]
pub struct DiagnosticListError {
    pub diagnostics: Vec<DiagnosticError>,
}

#[derive(Error, Debug, Diagnostic)]
#[error("{message}")]
#[diagnostic()]
pub struct DiagnosticError {
    // The Source that we're gonna be printing snippets out of.
    // This can be a String if you don't have or care about file names.
    pub message: String,
    #[source_code]
    pub src: NamedSource<String>,
    // Snippets and highlights can be included in the diagnostic!
    #[label("{label}")]
    pub bad_bit: SourceSpan,
    pub label: String,
}

impl DiagnosticError {
    pub fn from_label(filename: &str, source: &str, label: LabeledSpan) -> Self {
        let span: SourceSpan = (label.offset(), label.len()).into();
        let label_text = label.label().unwrap_or("error").to_string();
        Self {
            message: "Parse source error:".to_string(),
            src: NamedSource::new(filename, source.to_owned()).with_language("idl"),
            bad_bit: span,
            label: label_text,
        }
    }
}

pub type IdlcResult<T> = std::result::Result<T, IdlcError>;

impl IdlcError {
    pub fn template(message: impl Into<String>) -> Self {
        Self::Template(message.into())
    }

    pub fn rpc(message: impl Into<String>) -> Self {
        Self::Rpc(message.into())
    }

    pub fn fmt(message: impl Into<String>) -> Self {
        Self::Fmt(message.into())
    }

    pub fn diagnostic(err: DiagnosticError) -> Self {
        Self::Diagnostics(DiagnosticListError {
            diagnostics: vec![err],
        })
    }

    pub fn diagnostics(diagnostics: Vec<DiagnosticError>) -> Self {
        Self::Diagnostics(DiagnosticListError { diagnostics })
    }
}