rtlola2solidity 0.1.0

A compiler from RTLola to Solidity through StreamIR
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

use itertools::Itertools;
use rtlola_streamir::{
    formatter::{
        expressions::ExprFormatter,
        files::{FilesFormatter, Requirement},
        types::TypeFormatter,
    },
    ir::{expressions::Expr, Type},
};
use std::fmt::Write;

use crate::{RequirementKey, SolidityFormatter};

impl TypeFormatter for SolidityFormatter {
    type Return = String;

    fn type_int(&self, bits: u16) -> Self::Return {
        format!("int{bits}")
    }

    fn type_uint(&self, bits: u16) -> Self::Return {
        format!("uint{bits}")
    }

    fn type_bool(&self) -> Self::Return {
        "bool".into()
    }

    fn type_string(&self) -> Self::Return {
        "string".into()
    }

    fn type_float32(&self) -> Self::Return {
        panic!("not supported in solidity")
    }

    fn type_float64(&self) -> Self::Return {
        panic!("not supported in solidity")
    }

    fn type_option(&self, _inner: Type) -> Self::Return {
        panic!("not supported in solidity")
    }

    fn type_tuple(&self, inner: Vec<Type>) -> Self::Return {
        let tuple = TupleType(inner);
        let ty = tuple.ty(self);
        self.add_requirement(tuple);
        ty
    }

    fn type_fixed(&self, _bits: u16) -> Self::Return {
        unimplemented!()
    }

    fn type_ufixed(&self, _bits: u16) -> Self::Return {
        unimplemented!()
    }

    fn type_bytes(&self) -> Self::Return {
        unimplemented!()
    }
}

pub(crate) struct TupleType(pub Vec<Type>);

impl TupleType {
    fn ty(&self, f: &SolidityFormatter) -> String {
        if self.0.is_empty() {
            "UNIT".into()
        } else {
            self.0.iter().cloned().map(|ty| f.ty(ty)).join("__")
        }
    }

    pub(crate) fn expr(&self, exprs: Vec<Expr>, f: &SolidityFormatter) -> String {
        format!(
            "{}({{{}}})",
            self.ty(f),
            exprs
                .into_iter()
                .enumerate()
                .map(|(i, exp)| format!("_{i}: {}", f.expr(exp)))
                .join(", ")
        )
    }
}

impl Requirement<SolidityFormatter> for TupleType {
    fn key(&self) -> <SolidityFormatter as FilesFormatter>::Key {
        RequirementKey::TupleDefinition(self.0.clone())
    }

    fn file(&self, formatter: &SolidityFormatter) -> std::path::PathBuf {
        formatter.file().into()
    }

    fn format(self, f: &SolidityFormatter) -> String {
        let name = self.ty(f);
        let fields = self.0.iter().cloned().map(|ty| f.ty(ty)).enumerate().fold(
            String::new(),
            |mut res, (i, ty)| {
                writeln!(res, "{ty} _{i};").unwrap();
                res
            },
        );
        format!("struct {name} {{\n{fields}\n}}")
    }
}

impl SolidityFormatter {
    pub(crate) fn type_with_storage(&self, ty: Type) -> String {
        match ty {
            ty @ Type::Tuple(_) => format!("{} memory", self.ty(ty)),
            other => self.ty(other),
        }
    }
}