datalit-macros-internals 0.1.0-alpha.4

Internals for the datalit crate
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

use proc_macro2::Span;
use syn::{
    Error, Ident,
    parse::{Parse, ParseStream},
    token::Paren,
};

use crate::state::{EntryState, StateOperation};

pub struct DirectiveEntry {
    #[expect(dead_code, reason = "Will shortly be implementing directives")]
    name: Ident,
    #[expect(dead_code, reason = "Will shortly be implementing directives")]
    args: Paren,
    directive: Directive,
}

impl DirectiveEntry {
    pub fn peek(input: ParseStream) -> bool {
        input.peek(Ident) && input.peek2(Paren) && !input.peek3(syn::Token![:])
    }
}

impl Parse for DirectiveEntry {
    fn parse(input: ParseStream) -> syn::Result<Self> {
        let name: Ident = input.parse()?;
        let arg_content;
        let args: Paren = syn::parenthesized!(arg_content in input);
        let directive = Directive::parse(name.span(), &name.to_string(), &arg_content)?;
        Ok(Self {
            name,
            args,
            directive,
        })
    }
}

impl StateOperation for DirectiveEntry {
    fn apply_to(&self, state: &mut EntryState) -> syn::Result<()> {
        self.directive.apply_to(state)
    }
}

pub enum Directive {
    Align(AlignDirective),
}

impl Directive {
    fn parse(call_span: Span, name: &str, args: ParseStream) -> syn::Result<Self> {
        Ok(match name {
            "align" => Directive::Align(AlignDirective::parse(args)?),
            _ => {
                return Err(Error::new(
                    call_span,
                    format!("Unknown directive name: '{}'", name),
                ));
            }
        })
    }
}

impl StateOperation for Directive {
    fn apply_to(&self, state: &mut EntryState) -> syn::Result<()> {
        match self {
            Directive::Align(align_directive) => align_directive.apply_to(state),
        }
    }
}

#[derive(derive_syn_parse::Parse)]
pub struct AlignDirective {
    alignment: syn::LitInt,
    _trailing: Option<syn::Token![,]>,
}

impl StateOperation for AlignDirective {
    fn apply_to(&self, state: &mut EntryState) -> syn::Result<()> {
        let alignment = self.alignment.base10_parse::<usize>()?;
        if !alignment.is_power_of_two() {
            return Err(Error::new_spanned(
                &self.alignment,
                "Alignment must be a power of two",
            ));
        }
        let curr_offset = state.curr_offset();
        state.advance_bytes(curr_offset.next_multiple_of(alignment) - curr_offset);
        Ok(())
    }
}