mers_lib 0.9.29

library to use the mers language in other projects
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

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

use crate::{
    data::{self, Data, Type},
    errors::{CheckError, SourceRange},
};

use super::MersStatement;

#[derive(Debug)]
pub struct Variable {
    pub pos_in_src: SourceRange,
    pub is_init: bool,
    // if `is_init` is true, this must also be true unless using the "ignore" `_` pattern
    pub is_ref_not_ignore: bool,
    pub var: (usize, usize),
}

impl MersStatement for Variable {
    fn has_scope(&self) -> bool {
        false
    }
    fn check_custom(
        &self,
        info: &mut super::CheckInfo,
        init_to: Option<&Type>,
    ) -> Result<data::Type, super::CheckError> {
        if self.is_init {
            if self.is_ref_not_ignore {
                while info.scopes[self.var.0].vars.len() <= self.var.1 {
                    info.scopes[self.var.0].vars.push(Type::empty());
                }
                info.scopes[self.var.0].vars[self.var.1] = init_to
                    .expect("variable's is_init was true, but check_custom's assign was None? How?")
                    .clone();
            } else {
                return Ok(Type::new(data::reference::ReferenceT(
                    init_to
                        .expect("var's is_init was true, but init_to was None???")
                        .clone(),
                )));
            }
        }
        let val = if self.is_ref_not_ignore {
            Type::new(data::reference::ReferenceT(
                info.scopes[self.var.0].vars[self.var.1].clone(),
            ))
        } else {
            info.scopes[self.var.0].vars[self.var.1].clone()
        };
        Ok(val)
    }
    fn run_custom(&self, info: &mut super::Info) -> Result<Data, CheckError> {
        if self.is_init {
            if self.is_ref_not_ignore {
                let nothing = Arc::new(RwLock::new(Data::new(data::bool::Bool(false))));
                while info.scopes[self.var.0].vars.len() <= self.var.1 {
                    info.scopes[self.var.0].vars.push(Arc::clone(&nothing));
                }
                info.scopes[self.var.0].vars[self.var.1] = nothing;
            } else {
                // (reference to) data which will never be referenced again
                return Ok(Data::new(data::reference::Reference::from(
                    Data::empty_tuple(),
                )));
            }
        }
        Ok(if self.is_ref_not_ignore {
            let v = &info.scopes[self.var.0].vars[self.var.1];
            Data::new(data::reference::Reference::raw(Arc::clone(v)))
        } else {
            info.scopes[self.var.0].vars[self.var.1]
                .write()
                .unwrap()
                .clone()
        })
    }
    fn source_range(&self) -> SourceRange {
        self.pos_in_src.clone()
    }
    fn inner_statements(&self) -> Vec<&dyn MersStatement> {
        vec![]
    }
    fn as_any(&self) -> &dyn std::any::Any {
        self
    }
}