rtlola-streamir 0.1.0

A framework for the compilation of stream-based languages through an intermediate representation
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

use std::collections::HashMap;

use crate::ir::{memory::Memory, Guard, IfStmt, LivetimeEquivalences, Stmt, StreamReference};

use super::{ChangeSet, RewriteError, RewriteRule};

#[derive(Debug, Clone, Copy)]
/// A rewriting rule that removes if statements with a constant guard condition.
pub struct RemoveIfs;

impl RewriteRule for RemoveIfs {
    fn rewrite_stmt(
        &self,
        stmt: Stmt,
        _memory: &HashMap<StreamReference, Memory>,
        _liveness_equivalences: &LivetimeEquivalences,
    ) -> Result<(Stmt, ChangeSet), RewriteError> {
        match stmt {
            Stmt::If(IfStmt {
                guard: Guard::Constant(true),
                cons,
                alt: _,
            }) => Ok((*cons, ChangeSet::local_change())),
            Stmt::If(IfStmt {
                guard: Guard::Constant(false),
                cons: _,
                alt,
            }) => Ok((*alt, ChangeSet::local_change())),
            other => Ok((other, ChangeSet::default())),
        }
    }
}

#[cfg(test)]
mod tests {
    use crate::{
        ir::parse::parse_ir,
        rewrite_rules::{remove_ifs::RemoveIfs, Rewriter},
    };

    #[test]
    fn constant_true() {
        let ir = parse_ir(
            "
		if true then
			input 0
		else
			input 1
		fi	
		",
        );
        let reference = parse_ir("input 0");
        let rewriter = Rewriter::new(vec![Box::new(RemoveIfs {})]);
        let (res, changed) = rewriter.apply(ir).unwrap();
        assert!(changed);
        assert!(res.stmt.eq(&reference.stmt));
    }

    #[test]
    fn constant_false() {
        let ir = parse_ir(
            "
		if false then
			input 0
		else
			input 1
		fi	
		",
        );
        let reference = parse_ir("input 1");
        let rewriter = Rewriter::new(vec![Box::new(RemoveIfs {})]);
        let (res, changed) = rewriter.apply(ir).unwrap();
        assert!(changed);
        assert!(res.stmt.eq(&reference.stmt));
    }

    #[test]
    fn no_constant() {
        let ir = parse_ir(
            "
		if @0 then
			input 0
		else
			input 1
		fi	
		",
        );
        let rewriter = Rewriter::new(vec![Box::new(RemoveIfs {})]);
        let (res, changed) = rewriter.apply(ir.clone()).unwrap();
        assert!(!changed);
        assert!(res.stmt.eq(&ir.stmt));
    }
}