yulang-native 0.1.1

Native backend experiments for Yulang
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
106
107

use crate::cps_ir::{CpsContinuationId, CpsModule, CpsValueId};

#[derive(Debug, Clone, PartialEq, Eq)]
pub struct CpsEnvironmentLayout {
    pub functions: Vec<CpsFunctionEnvironmentLayout>,
    pub roots: Vec<CpsFunctionEnvironmentLayout>,
}

#[derive(Debug, Clone, PartialEq, Eq)]
pub struct CpsFunctionEnvironmentLayout {
    pub name: String,
    pub continuations: Vec<CpsContinuationEnvironmentLayout>,
}

#[derive(Debug, Clone, PartialEq, Eq)]
pub struct CpsContinuationEnvironmentLayout {
    pub continuation: CpsContinuationId,
    pub slots: Vec<CpsEnvironmentSlot>,
}

#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub struct CpsEnvironmentSlot {
    pub index: usize,
    pub value: CpsValueId,
}

pub fn layout_cps_environments(module: &CpsModule) -> CpsEnvironmentLayout {
    CpsEnvironmentLayout {
        functions: module
            .functions
            .iter()
            .map(layout_function_environments)
            .collect(),
        roots: module
            .roots
            .iter()
            .map(layout_function_environments)
            .collect(),
    }
}

fn layout_function_environments(
    function: &crate::cps_ir::CpsFunction,
) -> CpsFunctionEnvironmentLayout {
    CpsFunctionEnvironmentLayout {
        name: function.name.clone(),
        continuations: function
            .continuations
            .iter()
            .map(|continuation| CpsContinuationEnvironmentLayout {
                continuation: continuation.id,
                slots: continuation
                    .captures
                    .iter()
                    .copied()
                    .enumerate()
                    .map(|(index, value)| CpsEnvironmentSlot { index, value })
                    .collect(),
            })
            .collect(),
    }
}

#[cfg(test)]
mod tests {
    use crate::cps_ir::{
        CpsContinuation, CpsContinuationId, CpsFunction, CpsModule, CpsShotKind, CpsTerminator,
        CpsValueId,
    };

    use super::*;

    #[test]
    fn assigns_stable_slots_from_continuation_capture_order() {
        let module = CpsModule {
            functions: Vec::new(),
            roots: vec![CpsFunction {
                name: "root".to_string(),
                params: Vec::new(),
                entry: CpsContinuationId(0),
                continuations: vec![CpsContinuation {
                    id: CpsContinuationId(0),
                    params: Vec::new(),
                    captures: vec![CpsValueId(4), CpsValueId(2)],
                    shot_kind: CpsShotKind::MultiShot,
                    stmts: Vec::new(),
                    terminator: CpsTerminator::Return(CpsValueId(4)),
                }],
                handlers: Vec::new(),
            }],
        };

        assert_eq!(
            layout_cps_environments(&module).roots[0].continuations[0].slots,
            vec![
                CpsEnvironmentSlot {
                    index: 0,
                    value: CpsValueId(4),
                },
                CpsEnvironmentSlot {
                    index: 1,
                    value: CpsValueId(2),
                },
            ]
        );
    }
}