thalir-core 0.1.0

Core IR types and builders for ThalIR smart contract analysis
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

use crate::{
    block::BlockId,
    types::TypeRegistry,
    values::{TempId, VarId},
};
use std::collections::HashMap;

#[derive(Debug, Clone)]
pub struct SourceMapping {
    pub file: String,
    pub line: u32,
    pub column: u32,
    pub length: u32,
}

#[derive(Debug, Default)]
pub struct SSATracker {
    variables: HashMap<String, VarId>,
    versions: HashMap<VarId, u32>,
    next_var_id: u32,
    next_temp_id: u32,
}

impl SSATracker {
    pub fn new() -> Self {
        Self::default()
    }

    pub fn get_or_create_var(&mut self, name: &str) -> VarId {
        if let Some(&id) = self.variables.get(name) {
            id
        } else {
            let id = VarId(self.next_var_id);
            self.next_var_id += 1;
            self.variables.insert(name.to_string(), id);
            self.versions.insert(id, 0);
            id
        }
    }

    pub fn new_temp(&mut self) -> TempId {
        let id = TempId(self.next_temp_id);
        self.next_temp_id += 1;
        id
    }

    pub fn get_version(&self, var: VarId) -> u32 {
        self.versions.get(&var).copied().unwrap_or(0)
    }

    pub fn increment_version(&mut self, var: VarId) -> u32 {
        let version = self.get_version(var) + 1;
        self.versions.insert(var, version);
        version
    }
}

pub struct IRContext {
    source_mappings: HashMap<String, SourceMapping>,
    id_counter: u64,
    type_registry: TypeRegistry,
    ssa_tracker: SSATracker,
    current_contract: Option<String>,
    current_function: Option<String>,
    current_block: Option<BlockId>,
    errors: Vec<String>,
}

impl IRContext {
    pub fn new() -> Self {
        Self {
            source_mappings: HashMap::new(),
            id_counter: 1,
            type_registry: TypeRegistry::new(),
            ssa_tracker: SSATracker::new(),
            current_contract: None,
            current_function: None,
            current_block: None,
            errors: Vec::new(),
        }
    }

    pub fn next_id(&mut self) -> u64 {
        let id = self.id_counter;
        self.id_counter += 1;
        id
    }

    pub fn next_string_id(&mut self, prefix: &str) -> String {
        format!("{}_{}", prefix, self.next_id())
    }

    pub fn add_source_mapping(&mut self, id: String, mapping: SourceMapping) {
        self.source_mappings.insert(id, mapping);
    }

    pub fn get_source_mapping(&self, id: &str) -> Option<&SourceMapping> {
        self.source_mappings.get(id)
    }

    pub fn set_current_contract(&mut self, name: String) {
        self.current_contract = Some(name);
    }

    pub fn current_contract(&self) -> Option<&str> {
        self.current_contract.as_deref()
    }

    pub fn set_current_function(&mut self, name: String) {
        self.current_function = Some(name);
    }

    pub fn current_function(&self) -> Option<&str> {
        self.current_function.as_deref()
    }

    pub fn set_current_block(&mut self, block: BlockId) {
        self.current_block = Some(block);
    }

    pub fn current_block(&self) -> Option<BlockId> {
        self.current_block
    }

    pub fn ssa(&mut self) -> &mut SSATracker {
        &mut self.ssa_tracker
    }

    pub fn types(&mut self) -> &mut TypeRegistry {
        &mut self.type_registry
    }

    pub fn add_error(&mut self, error: String) {
        self.errors.push(error);
    }

    pub fn has_errors(&self) -> bool {
        !self.errors.is_empty()
    }

    pub fn errors(&self) -> &[String] {
        &self.errors
    }

    pub fn clear(&mut self) {
        self.source_mappings.clear();
        self.id_counter = 1;
        self.ssa_tracker = SSATracker::new();
        self.current_contract = None;
        self.current_function = None;
        self.current_block = None;
        self.errors.clear();
    }
}