repetitive 0.2.0

Macro for generating repetitive code
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
103
104
105

use std::sync::{Arc, Mutex};

use string_interner::{DefaultStringInterner, DefaultSymbol};
use syn::{Ident, Token};

use super::*;

pub struct Context {
    interner: DefaultStringInterner,
    method_calls: Vec<(Token![.], Option<Ident>)>,
    error_arcs: Vec<Arc<Mutex<Option<Error>>>>,
    warning_arcs: Vec<Arc<Mutex<Option<Warning>>>>,
}

#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
pub struct StrId {
    inner: DefaultSymbol,
}

#[derive(Debug, Clone)]
pub struct ErrorHandle {
    option_arc: Arc<Mutex<Option<Error>>>,
}

#[derive(Debug, Clone)]
pub struct WarningHandle {
    option_arc: Arc<Mutex<Option<Warning>>>,
}

impl Context {
    pub fn new() -> Self {
        Self {
            interner: DefaultStringInterner::new(),
            method_calls: Vec::new(),
            error_arcs: Vec::new(),
            warning_arcs: Vec::new(),
        }
    }

    pub fn intern(&mut self, s: &str) -> StrId {
        StrId {
            inner: self.interner.get_or_intern(s.to_string()),
        }
    }
    pub fn unintern(&self, id: StrId) -> &str {
        self.interner.resolve(id.inner).unwrap()
    }

    pub fn push_method_call(&mut self, dot: Token![.], method: Option<Ident>) {
        self.method_calls.push((dot, method));
    }
    pub fn get_method_calls(&self) -> &[(Token![.], Option<Ident>)] {
        &self.method_calls
    }

    pub fn push_error(&mut self, error: Error) -> ErrorHandle {
        let option_arc = Arc::new(Mutex::new(Some(error)));
        self.error_arcs.push(option_arc.clone());

        println!("pushng error {}", self.error_arcs.len());

        ErrorHandle { option_arc }
    }
    pub fn has_errors(&self) -> bool {
        self.error_arcs
            .iter()
            .any(|arc| arc.lock().unwrap().is_some())
    }
    pub fn take_errors(&self) -> impl Iterator<Item = Error> {
        self.error_arcs
            .iter()
            .filter_map(|arc| arc.lock().unwrap().take())
    }

    pub fn push_warning(&mut self, warning: Warning) -> WarningHandle {
        let option_arc = Arc::new(Mutex::new(Some(warning)));
        self.warning_arcs.push(option_arc.clone());

        WarningHandle { option_arc }
    }
    #[expect(dead_code)]
    pub fn has_warnings(&self) -> bool {
        self.warning_arcs
            .iter()
            .any(|arc| arc.lock().unwrap().is_some())
    }
    pub fn take_warnings(&self) -> impl Iterator<Item = Warning> {
        self.warning_arcs
            .iter()
            .filter_map(|arc| arc.lock().unwrap().take())
    }
}

impl ErrorHandle {
    #[expect(dead_code)]
    pub fn remove(&self) {
        *self.option_arc.lock().unwrap() = None;
    }
}

impl WarningHandle {
    pub fn remove(&self) {
        *self.option_arc.lock().unwrap() = None;
    }
}