roto 0.10.0

a statically-typed, compiled, embedded scripting language
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
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157

//! Mid-level intermediate representation (MIR)
//!
//! This is the first intermediate representation. It is based on basic blocks
//! and simple expressions. We do not distinguish between types that are stored
//! in stack slots and types that are cranelift values; all types are treated
//! equally in this representation.

mod dead_code;
mod lower;
mod print;

use crate::{
    ast::{BinOp, Identifier, Literal},
    label::LabelRef,
    runtime,
    typechecker::{
        scope::{ResolvedName, ScopeRef},
        types::{EnumVariant, Signature, Type},
    },
};
pub use lower::lower_to_mir;

/// Human-readable place
#[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Hash)]
#[must_use]
pub struct Var {
    pub scope: ScopeRef,
    pub kind: VarKind,
}

#[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Hash)]
pub enum VarKind {
    Explicit(Identifier),
    Tmp(usize),
}

#[derive(Clone, Debug)]
pub struct Mir {
    pub functions: Vec<Function>,
}

#[derive(Clone, Debug)]
pub struct Function {
    /// Name of this function
    pub name: Identifier,

    /// Scope that belongs to this function
    pub scope: ScopeRef,

    pub variables: Vec<(Var, Type)>,

    /// Parameters to this function
    pub parameters: Vec<Var>,

    /// The function signature
    pub signature: Signature,

    /// Basic blocks of this function
    ///
    /// The first block is the entrypoint.
    pub blocks: Vec<Block>,

    /// Index of the largest temporary variable in this function
    pub tmp_idx: usize,
}

#[derive(Clone, Debug)]
pub struct Block {
    pub label: LabelRef,
    pub instructions: Vec<Instruction>,
}

#[derive(Clone, Debug)]
pub struct Place {
    pub var: Var,
    pub root_ty: Type,
    pub projection: Vec<Projection>,
}

impl Place {
    pub fn new(value: Var, ty: Type) -> Self {
        Self {
            var: value,
            root_ty: ty,
            projection: Vec::new(),
        }
    }
}

#[derive(Clone, Debug)]
pub enum Projection {
    VariantField(Identifier, usize),
    Field(Identifier),
}

#[derive(Clone, Debug)]
#[must_use]
pub enum Value {
    Const(Literal, Type),
    Constant(ResolvedName, Type),
    Context(usize),
    Clone(Place),
    Discriminant(Var),
    Not(Var),
    Negate(Var, Type),
    Move(Var),
    BinOp {
        left: Var,
        binop: BinOp,
        ty: Type,
        right: Var,
    },
    Call {
        func: ResolvedName,
        args: Vec<Var>,
    },
    CallRuntime {
        func_ref: runtime::RuntimeFunctionRef,
        args: Vec<Var>,
        type_params: Vec<Type>,
    },
}

#[derive(Clone, Debug)]
pub enum Instruction {
    /// Jump to a block
    Jump(LabelRef),

    /// Switch on the integer value of the `examinee`
    Switch {
        examinee: Var,
        branches: Vec<(usize, LabelRef)>,
        default: Option<LabelRef>,
    },

    Assign {
        to: Place,
        ty: Type,
        value: Value,
    },

    SetDiscriminant {
        to: Var,
        ty: Type,
        variant: EnumVariant,
    },

    /// Return from the current function (or filtermap)
    Return {
        var: Var,
    },

    Drop {
        val: Place,
        ty: Type,
    },
}