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

// SPDX-License-Identifier: Apache-2.0

use crate::sema::ast::Namespace;
use crate::sema::expression::ExprContext;
use crate::sema::symtable::{LoopScopes, Symtable};
use crate::sema::yul::ast::{YulBlock, YulStatement};
use crate::sema::yul::functions::{
    process_function_header, resolve_function_definition, FunctionsTable,
};
use crate::sema::yul::statements::resolve_yul_statement;
use solang_parser::{
    diagnostics::Diagnostic,
    pt::{self, CodeLocation},
};

/// Resolve an yul block.
/// Returns the resolved block and a boolean that tells us if the next statement is reachable.
pub fn resolve_yul_block(
    loc: &pt::Loc,
    statements: &[pt::YulStatement],
    context: &mut ExprContext,
    reachable: bool,
    loop_scope: &mut LoopScopes,
    function_table: &mut FunctionsTable,
    symtable: &mut Symtable,
    ns: &mut Namespace,
) -> (YulBlock, bool) {
    function_table.enter_scope();
    context.enter_scope();

    let (body, mut next_reachable) = process_statements(
        statements,
        context,
        reachable,
        symtable,
        loop_scope,
        function_table,
        ns,
    );

    next_reachable &= reachable;
    context.leave_scope(symtable, *loc);
    function_table.leave_scope(ns);

    (
        YulBlock {
            loc: *loc,
            reachable,
            next_reachable,
            statements: body,
        },
        next_reachable,
    )
}

/// Resolves an array of yul statements.
/// Returns a vector of tuples (resolved_statement, reachable) and a boolean that tells us if the
/// next statement is reachable
pub(crate) fn process_statements(
    statements: &[pt::YulStatement],
    context: &mut ExprContext,
    mut reachable: bool,
    symtable: &mut Symtable,
    loop_scope: &mut LoopScopes,
    functions_table: &mut FunctionsTable,
    ns: &mut Namespace,
) -> (Vec<YulStatement>, bool) {
    let mut func_count: usize = 0;
    for item in statements {
        if let pt::YulStatement::FunctionDefinition(fun_def) = item {
            process_function_header(fun_def, functions_table, ns);
            func_count += 1;
        }
    }

    for item in statements {
        if let pt::YulStatement::FunctionDefinition(func_def) = item {
            // If an error was generate while processing the function header, it is not added to the
            // functions table, so we do not resolve its body.
            let index = if let Some(index) = functions_table.function_index(&func_def.id.name) {
                index
            } else {
                continue;
            };

            if let Ok(resolved_func) =
                resolve_function_definition(func_def, functions_table, context, ns)
            {
                functions_table.resolved_functions[index] = resolved_func;
            }
        }
    }

    let mut body: Vec<YulStatement> = Vec::with_capacity(statements.len() - func_count);
    let mut has_unreachable = false;
    for item in statements {
        match resolve_yul_statement(
            item,
            context,
            reachable,
            loop_scope,
            symtable,
            &mut body,
            functions_table,
            ns,
        ) {
            Ok(can_reach_next_statement) => {
                /* There shouldn't be warnings of unreachable statements for function definitions.
                    let x := foo(1, 2)
                    return(x, 2)
                    function foo(a, b) -> ret {
                        ret := add(a, b)
                    }
                The function definition is not unreachable, because it does not execute anything.
                */
                if !reachable
                    && !has_unreachable
                    && !matches!(item, pt::YulStatement::FunctionDefinition(..))
                {
                    ns.diagnostics.push(Diagnostic::warning(
                        item.loc(),
                        "unreachable yul statement".to_string(),
                    ));
                    has_unreachable = true;
                }
                reachable &= can_reach_next_statement;
            }
            Err(_) => {
                break;
            }
        }
    }

    (body, reachable)
}