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
80
81
82
83
84
85
86
87
88

//! Complete axis-set verification.
use super::super::cargo::{AxisCargo, CargoAxis, ProvedCargo, SupportAxes};
use super::AssemblyIssue;
use crate::identity::{self, Identity};
pub(super) fn carried_axes(axes: &SupportAxes) -> Vec<(CargoAxis, &ProvedCargo)> {
    [
        (CargoAxis::Deferred, held(&axes.deferred)),
        (CargoAxis::Bench, held(&axes.bench)),
    ]
    .into_iter()
    .filter_map(|(axis, cargo)| cargo.map(|proved| (axis, proved)))
    .collect()
}
pub(super) fn root_issues(
    root: Identity<identity::CapturedDeclaration>,
    axes: &SupportAxes,
    carried: &[(CargoAxis, &ProvedCargo)],
) -> Vec<AssemblyIssue> {
    let mut issues = Vec::new();
    if let AxisCargo::Carried(declared) = &axes.declared
        && declared.root() != root
    {
        issues.push(AssemblyIssue::RootsDisagree {
            axis: CargoAxis::Declared,
            stated: root,
            carried: declared.root(),
        });
    }
    issues.extend(
        carried
            .iter()
            .filter(|(_, proved)| proved.root() != root)
            .map(|(axis, proved)| AssemblyIssue::RootsDisagree {
                axis: *axis,
                stated: root,
                carried: proved.root(),
            }),
    );
    issues
}
pub(super) fn destination_issues(carried: &[(CargoAxis, &ProvedCargo)]) -> Vec<AssemblyIssue> {
    carried
        .iter()
        .filter(|(axis, proved)| axis.reads_from() != proved.destination())
        .map(
            |(axis, proved)| AssemblyIssue::CargoReachesASecondDestination {
                axis: *axis,
                destination: proved.destination(),
            },
        )
        .collect()
}
pub(super) fn consumption_issues(carried: &[(CargoAxis, &ProvedCargo)]) -> Vec<AssemblyIssue> {
    let mut issues = Vec::new();
    for (position, (_, proved)) in carried.iter().enumerate() {
        if carried.iter().take(position).any(|(_, other)| {
            other.source() == proved.source() && other.destination() == proved.destination()
        }) {
            issues.push(AssemblyIssue::CargoConsumedTwice {
                source: proved.source(),
                destination: proved.destination(),
            });
        }
    }
    issues
}
pub(super) fn form_issues(axes: &SupportAxes) -> Vec<AssemblyIssue> {
    let mut issues = Vec::new();
    if matches!(&axes.deferred, AxisCargo::Carried(_))
        && matches!(&axes.bench, AxisCargo::Carried(_))
    {
        issues.push(AssemblyIssue::TwoFormsCarried);
    }
    if matches!(&axes.bench, AxisCargo::Carried(_))
        && matches!(&axes.declared, AxisCargo::Absent { .. })
    {
        issues.push(AssemblyIssue::StampedCargoAbsent {
            form: super::super::types::DeliveryForm::Benches,
        });
    }
    issues
}
fn held(axis: &AxisCargo<ProvedCargo>) -> Option<&ProvedCargo> {
    match axis {
        AxisCargo::Absent { .. } => None,
        AxisCargo::Carried(proved) => Some(proved),
    }
}