pintc 0.14.0

Compiler for the Pint 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

use super::{Contract, DisplayWithPred, ExprKey, Ident, Predicate};
use crate::{
    error::{ErrorEmitted, Handler},
    span::Span,
    types::Type,
};
use std::fmt::{self, Formatter};

/// A variable specification with an optional type.
#[derive(Clone, Debug)]
pub struct Variable {
    pub name: String,
    pub expr: ExprKey,
    pub span: Span,
}

slotmap::new_key_type! { pub struct VariableKey; }

#[derive(Debug, Default, Clone)]
pub struct Variables {
    variables: slotmap::SlotMap<VariableKey, Variable>,
    variable_types: slotmap::SecondaryMap<VariableKey, Type>,
    order: Vec<VariableKey>,
}

impl Variables {
    /// Returns a read-only iterator to the `variables` map
    pub fn variables(&self) -> impl Iterator<Item = (VariableKey, &Variable)> {
        self.order.iter().map(|&key| (key, &self.variables[key]))
    }

    /// Returns the order of the provided `VariableKey` as tracked in the `order` vector
    pub fn position(&self, key: VariableKey) -> Option<usize> {
        self.order.iter().position(|k| *k == key)
    }

    /// Inserts a variable variable with its type
    pub fn insert(&mut self, variable: Variable, ty: Type) -> VariableKey {
        let key = self.variables.insert(variable);
        self.variable_types.insert(key, ty);
        self.order.push(key);
        key
    }

    /// Inserts a variable variable with its type at a particular position
    pub fn insert_at(&mut self, index: usize, variable: Variable, ty: Type) -> VariableKey {
        let key = self.variables.insert(variable);
        self.variable_types.insert(key, ty);
        self.order.insert(index, key);
        key
    }

    /// Removes a variable variable and its type given a `VariableKey`
    pub fn remove(&mut self, key: VariableKey) {
        self.variables.remove(key);
        self.variable_types.remove(key);
        self.order.retain(|el| *el != key);
    }

    /// Apply function `f` on every variable
    pub fn update_variables(&mut self, f: impl FnOnce(&mut Variable) + std::marker::Copy) {
        for (_, variable) in self.variables.iter_mut() {
            f(variable)
        }
    }

    /// Apply function `f` on every variable type
    /// Only the `Type`s can be mutated, not the keys
    pub fn update_types(&mut self, f: impl FnOnce(VariableKey, &mut Type) + std::marker::Copy) {
        for (key, ty) in self.variable_types.iter_mut() {
            f(key, ty)
        }
    }
}

impl VariableKey {
    /// Returns an `Option` containing the `Variable` corresponding to key `self`. Returns `None` if
    /// the key can't be found in the `variables` map.
    pub fn try_get<'a>(&self, pred: &'a Predicate) -> Option<&'a Variable> {
        pred.variables.variables.get(*self)
    }

    /// Returns the `Variable` corresponding to key `self`. Panics if the key can't be found in the
    /// `variables` map.
    pub fn get<'a>(&self, pred: &'a Predicate) -> &'a Variable {
        pred.variables.variables.get(*self).unwrap()
    }

    /// Returns the type of key `self` given a `Predicate`. Panics if the type can't be
    /// found in the `variable_types` map.
    pub fn get_ty<'a>(&self, pred: &'a Predicate) -> &'a Type {
        pred.variables.variable_types.get(*self).unwrap()
    }

    /// Set the type of key `self` in a `Predicate`. Panics if the type can't be found in
    /// the `variable_types` map.
    pub fn set_ty<'a>(&'a self, ty: Type, pred: &'a mut Predicate) {
        pred.variables.variable_types.insert(*self, ty);
    }
}

impl DisplayWithPred for VariableKey {
    fn fmt(&self, f: &mut Formatter, contract: &Contract, pred: &Predicate) -> fmt::Result {
        let variable = &self.get(pred);
        write!(f, "let {}", variable.name)?;
        let ty = self.get_ty(pred);
        if !ty.is_unknown() {
            write!(f, ": {}", contract.with_ctrct(ty))?;
        }
        write!(f, " = {}", contract.with_ctrct(&variable.expr))
    }
}

impl Predicate {
    #[allow(clippy::too_many_arguments)]
    pub fn insert_variable(
        &mut self,
        handler: &Handler,
        mod_prefix: &str,
        local_prefix: Option<&str>,
        name: &Ident,
        ty: Option<Type>,
        expr: ExprKey,
        span: Span,
    ) -> std::result::Result<VariableKey, ErrorEmitted> {
        let name =
            self.symbols
                .add_symbol(handler, mod_prefix, local_prefix, name, span.clone())?;
        let variable_key = self.variables.insert(
            Variable {
                name,
                expr,
                span: span.clone(),
            },
            if let Some(ty) = ty {
                ty
            } else {
                Type::Unknown(span.clone())
            },
        );

        Ok(variable_key)
    }

    pub(crate) fn variables(&self) -> impl Iterator<Item = (VariableKey, &Variable)> {
        self.variables.variables()
    }
}