aranya-capi-codegen 0.7.1

Code generation for Aranya's C API tooling
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
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102

use std::{cell::RefCell, fmt::Display};

use quote::ToTokens;
use syn::{Error, Ident, Path, Result};
use tracing::{error, instrument};

/// Code generation context.
#[derive(Debug)]
pub(crate) struct Ctx {
    /// The `#capi` in `extern aranya_capi_core as #capi`.
    pub capi: Ident,
    /// Path to `aranya_capi_core::internal::conv`.
    pub conv: Path,
    /// Path to `aranya_capi_core::internal::util`.
    pub util: Path,
    /// Path to `aranya_capi_core::internal::error`.
    pub error: Path,

    /// Path to the error code.
    pub err_ty: Path,
    /// Path to the extended error type.
    pub ext_err_ty: Path,

    /// Function identifier prefix.
    ///
    /// E.g., `os` converts `fn foo` to `fn os_foo`.
    pub fn_prefix: Ident,
    /// Type identifier prefix.
    ///
    /// E.g., `Os` converts `struct Foo` to `struct OsFoo`.
    pub ty_prefix: Ident,

    /// Path to the module where defs live.
    pub defs: Path,

    // Internal module paths for generated code.
    pub hidden: Ident,
    pub imports: Ident,

    /// Collected errors.
    ///
    /// We collect errors instead of immediately failing so that
    /// we can provide better error reporting.
    pub errs: RefCell<Errors>,
}

impl Ctx {
    /// Adds an error.
    pub fn error(&self, tokens: impl ToTokens, msg: impl Display) {
        self.errs.borrow_mut().error(tokens, msg);
    }

    /// Adds an [`Error`].
    pub fn push(&self, err: Error) {
        self.errs.borrow_mut().push(err);
    }

    /// Combines the errors, returning `Ok` if there are none or
    /// `Err` otherwise.
    pub fn propagate(&mut self) -> Result<()> {
        self.errs.borrow_mut().propagate()
    }
}

/// Taken from [`cxx`].
///
/// [`cxx`]: https://github.com/dtolnay/cxx/blob/afd4aa3f3d4e5d5e9a3a41d09df3408f5f86a469/syntax/report.rs
#[derive(Debug, Default)]
pub(crate) struct Errors(Vec<Error>);

impl Errors {
    #[instrument(skip_all)]
    fn push(&mut self, err: Error) {
        error!(%err);

        self.0.push(err);
    }

    fn error(&mut self, tokens: impl ToTokens, msg: impl Display) {
        // NB: We call `self.push` for logging purposes.
        self.push(Error::new_spanned(tokens, msg));
    }

    /// Combines the errors, returning `Ok` if there are none or
    /// `Err` otherwise.
    fn propagate(&mut self) -> Result<()> {
        let mut iter = self.0.drain(..);
        let mut all = match iter.next() {
            Some(err) => err,
            None => return Ok(()),
        };
        for err in iter {
            all.combine(err);
        }
        Err(all)
    }

    #[cfg(test)]
    pub(crate) fn clear(&mut self) {
        self.0.clear();
    }
}