macroonz-compiler 0.2.0

Deterministic Rust code generation for procedural macros: plan, render, close, explain, and bind one sealed expansion from declared input.
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

//! Recipe kind, role, lowering, refusal, and host-emission contracts.

#[cfg(feature = "host")]
use super::RecipeBake;
use super::types::{RecipeShell, RecipeShellContent};
use super::{ProjectionError, Recipe, RecipeProjection, RecipeRole};
use crate::bounded::Overflow;
use crate::kind::{Destination, Kind, NoQuestions, Role, SoleRole};
use crate::render::RenderError;
use core::fmt;

impl Role for RecipeRole {
    const ALL: &'static [Self] = Self::ALL;

    fn name(self) -> &'static str {
        Self::name(self)
    }

    fn destination(self) -> Destination {
        self.profile().output.destination
    }
}

impl Kind for RecipeProjection {
    const NAME: &'static str = "recipe-projection";
    type Content = Recipe;
    type Role = RecipeRole;
    type Question = NoQuestions;
}

impl Kind for RecipeShell {
    const NAME: &'static str = "recipe-emission";
    type Content = RecipeShellContent;
    type Role = SoleRole;
    type Question = NoQuestions;
}

impl fmt::Display for ProjectionError {
    fn fmt(&self, into: &mut fmt::Formatter<'_>) -> fmt::Result {
        match self {
            Self::Tokens(overflow) => write!(into, "{overflow}"),
            Self::Render(refusal) => write!(into, "{refusal}"),
        }
    }
}

impl core::error::Error for ProjectionError {
    fn source(&self) -> Option<&(dyn core::error::Error + 'static)> {
        match self {
            Self::Tokens(overflow) => Some(overflow),
            Self::Render(refusal) => Some(refusal),
        }
    }
}

impl From<Overflow> for ProjectionError {
    fn from(overflow: Overflow) -> Self {
        Self::Tokens(overflow)
    }
}

impl From<ProjectionError> for RenderError {
    fn from(refusal: ProjectionError) -> Self {
        match refusal {
            ProjectionError::Tokens(overflow) => Self::TokensUnbounded {
                bound: overflow.capacity,
                observed: overflow.offered,
            },
            ProjectionError::Render(render) => render,
        }
    }
}

#[cfg(feature = "host")]
impl crate::host::Emittable for RecipeBake {
    fn cargos(&self) -> impl Iterator<Item = &crate::closure::PartitionCargo> {
        core::iter::once(self.emit())
    }
}