solang 0.3.4

Solang Solidity Compiler
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

// SPDX-License-Identifier: Apache-2.0

use crate::codegen::subexpression_elimination::{
    AvailableExpression, AvailableExpressionSet, AvailableVariable, BasicExpression,
    ExpressionType, NodeId,
};
use crate::codegen::Expression;
use std::cell::RefCell;
use std::rc::Rc;

impl AvailableExpression {
    /// Add a node to represent a literal
    pub fn add_literal_node<'b, 'a: 'b>(
        &mut self,
        expr: &'a Expression,
        expr_set: &mut AvailableExpressionSet<'b>,
    ) -> NodeId {
        let expr_type = expr.get_constant_expression_type();

        self.add_node_to_memory(expr_set, expr_type, expr);

        self.global_id_counter - 1
    }

    /// Add a node to represent a variable
    pub fn add_variable_node<'b, 'a: 'b>(
        &mut self,
        expr: &'a Expression,
        expr_set: &mut AvailableExpressionSet<'b>,
    ) -> NodeId {
        let expr_type = match expr {
            Expression::Variable { var_no, .. } => ExpressionType::Variable(*var_no),

            Expression::FunctionArg { arg_no, .. } => ExpressionType::FunctionArg(*arg_no),

            _ => unreachable!("This expression is not a variable or a function argument"),
        };

        self.add_node_to_memory(expr_set, expr_type, expr);

        self.global_id_counter - 1
    }

    /// Add a node to represent a binary expression
    pub fn add_binary_node<'b, 'a: 'b>(
        &mut self,
        exp: &'a Expression,
        expr_set: &mut AvailableExpressionSet<'b>,
        left: NodeId,
        right: NodeId,
    ) -> NodeId {
        let operation = exp.get_ave_operator();
        let new_node = Rc::new(RefCell::new(BasicExpression {
            expr_type: ExpressionType::BinaryOperation(left, right, operation.clone()),
            expression_id: self.global_id_counter,
            children: Default::default(),
            available_variable: AvailableVariable::Unavailable,
            parent_block: None,
            block: self.cur_block,
            reference: exp,
        }));
        expr_set
            .expression_memory
            .insert(self.global_id_counter, Rc::clone(&new_node));

        expr_set.expr_map.insert(
            ExpressionType::BinaryOperation(left, right, operation),
            self.global_id_counter,
        );

        expr_set
            .expression_memory
            .get_mut(&left)
            .unwrap()
            .borrow_mut()
            .children
            .insert(self.global_id_counter, Rc::clone(&new_node));
        expr_set
            .expression_memory
            .get_mut(&right)
            .unwrap()
            .borrow_mut()
            .children
            .insert(self.global_id_counter, Rc::clone(&new_node));

        self.global_id_counter += 1;
        self.global_id_counter - 1
    }

    /// Add a node to represent an unary operation
    pub fn add_unary_node<'b, 'a: 'b>(
        &mut self,
        exp: &'a Expression,
        parent: usize,
        expr_set: &mut AvailableExpressionSet<'b>,
    ) -> NodeId {
        let operation = exp.get_ave_operator();
        let new_node = Rc::new(RefCell::new(BasicExpression {
            expr_type: ExpressionType::UnaryOperation(parent, operation.clone()),
            expression_id: self.global_id_counter,
            children: Default::default(),
            available_variable: AvailableVariable::Unavailable,
            parent_block: None,
            block: self.cur_block,
            reference: exp,
        }));

        expr_set
            .expression_memory
            .insert(self.global_id_counter, Rc::clone(&new_node));

        expr_set.expr_map.insert(
            ExpressionType::UnaryOperation(parent, operation),
            self.global_id_counter,
        );
        expr_set
            .expression_memory
            .get_mut(&parent)
            .unwrap()
            .borrow_mut()
            .children
            .insert(self.global_id_counter, Rc::clone(&new_node));

        self.global_id_counter += 1;

        self.global_id_counter - 1
    }

    fn add_node_to_memory<'b, 'a: 'b>(
        &mut self,
        expr_set: &mut AvailableExpressionSet<'b>,
        expr_type: ExpressionType,
        expr: &'a Expression,
    ) {
        expr_set.expression_memory.insert(
            self.global_id_counter,
            Rc::new(RefCell::new(BasicExpression {
                expr_type: expr_type.clone(),
                expression_id: self.global_id_counter,
                children: Default::default(),
                available_variable: AvailableVariable::Unavailable,
                parent_block: None,
                block: self.cur_block,
                reference: expr,
            })),
        );

        expr_set.expr_map.insert(expr_type, self.global_id_counter);
        self.global_id_counter += 1;
    }

    /// Set the current block being processed. We save this number in the BasicExpression node for
    /// each new expression.
    pub fn set_cur_block(&mut self, block_no: usize) {
        self.cur_block = block_no;
    }
}