mango 0.4.0

The Mango programming language (UNDER CONSTRUCTION)
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

use crate::util::errors::CodeProblem;
use crate::util::errors::Context;
use derive_new::new;
use std::slice;
use crate::common::error::ErrMsg;

#[derive(new, Debug)]
pub struct ProblemCollector {
    // Note that Vec is already heap-allocated, no need for box.
    #[new(value = "vec![]")]
    problems: Vec<CodeProblem>,
}

impl ProblemCollector {
    pub fn error(&mut self, description: ErrMsg, context: Context) -> &mut CodeProblem {
        let problem = CodeProblem::error(description, context);
        self.problems.push(problem);
        self.problems.last_mut().unwrap()
    }

    pub fn warning(&mut self, description: ErrMsg, context: Context) -> &mut CodeProblem {
        let problem = CodeProblem::warning(description, context);
        self.problems.push(problem);
        self.problems.last_mut().unwrap()
    }

    pub fn debug(&mut self, description: ErrMsg, context: Context) -> &mut CodeProblem {
        let problem = CodeProblem::debug(description, context);
        self.problems.push(problem);
        self.problems.last_mut().unwrap()
    }
}

impl<'a> IntoIterator for &'a ProblemCollector {
    type Item = &'a CodeProblem;
    type IntoIter = slice::Iter<'a, CodeProblem>;

    fn into_iter(self) -> Self::IntoIter {
        self.problems.iter()
    }
}

#[cfg(test)]
mod tests {
    use super::ProblemCollector;
    use crate::util::errors::Context;
    use crate::util::strtype::StrType;

    #[test]
    fn test_iter_collector() {
        let mut collector = ProblemCollector::new();
        collector.error(Msg::new("test problem").unwrap(), Context::new("test context".to_string()));
        let cnt = collector.into_iter().count();
        assert_eq!(1, cnt, "No item in ProblemCollector");
        assert_eq!(cnt, collector.into_iter().count(), "Failed to iterate over ProblemCollector twice")
    }

    #[test]
    fn test_new_problem() {
        let mut collector = ProblemCollector::new();
        collector.error(Msg::new("test problem").unwrap(), Context::new("test context".to_string()));
        collector.warning(Msg::new("test problem").unwrap(), Context::new("test context".to_string()));
        collector.debug(Msg::new("test problem").unwrap(), Context::new("test context".to_string()));
    }
}