neo-devpack-solidity 0.22.0

Production-focused Solidity-to-NeoVM compilation system
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

fn rewrite_statement(
    stmt: &Statement,
    subs: &std::collections::HashMap<String, Expression>,
    placeholder_body: Option<&Statement>,
) -> Statement {
    if modifier_placeholder_stmt(stmt) {
        if let Some(body) = placeholder_body {
            return body.clone();
        }
    }

    match stmt {
        Statement::Block {
            loc,
            unchecked,
            statements,
        } => Statement::Block {
            loc: *loc,
            unchecked: *unchecked,
            statements: statements
                .iter()
                .map(|s| rewrite_statement(s, subs, placeholder_body))
                .collect(),
        },
        Statement::Assembly { .. } => stmt.clone(),
        Statement::Args(loc, args) => {
            let rewritten_args: Vec<NamedArgument> = args
                .iter()
                .map(|arg| NamedArgument {
                    loc: arg.loc,
                    name: arg.name.clone(),
                    expr: rewrite_expression(&arg.expr, subs),
                })
                .collect();
            Statement::Args(*loc, rewritten_args)
        }
        Statement::If(loc, cond, then_stmt, else_stmt) => Statement::If(
            *loc,
            rewrite_expression(cond, subs),
            Box::new(rewrite_statement(then_stmt, subs, placeholder_body)),
            else_stmt
                .as_ref()
                .map(|s| Box::new(rewrite_statement(s, subs, placeholder_body))),
        ),
        Statement::While(loc, cond, body) => Statement::While(
            *loc,
            rewrite_expression(cond, subs),
            Box::new(rewrite_statement(body, subs, placeholder_body)),
        ),
        Statement::Expression(loc, expr) => {
            Statement::Expression(*loc, rewrite_expression(expr, subs))
        }
        Statement::VariableDefinition(loc, decl, init) => Statement::VariableDefinition(
            *loc,
            decl.clone(),
            init.as_ref().map(|e| rewrite_expression(e, subs)),
        ),
        Statement::For(loc, init, cond, next, body) => Statement::For(
            *loc,
            init.as_ref()
                .map(|s| Box::new(rewrite_statement(s, subs, placeholder_body))),
            cond.as_ref().map(|e| Box::new(rewrite_expression(e, subs))),
            next.as_ref().map(|e| Box::new(rewrite_expression(e, subs))),
            body.as_ref()
                .map(|s| Box::new(rewrite_statement(s, subs, placeholder_body))),
        ),
        Statement::DoWhile(loc, body, cond) => Statement::DoWhile(
            *loc,
            Box::new(rewrite_statement(body, subs, placeholder_body)),
            rewrite_expression(cond, subs),
        ),
        Statement::Continue(_) | Statement::Break(_) => stmt.clone(),
        Statement::Return(loc, expr) => {
            Statement::Return(*loc, expr.as_ref().map(|e| rewrite_expression(e, subs)))
        }
        Statement::Revert(loc, path, args) => Statement::Revert(
            *loc,
            path.clone(),
            args.iter().map(|e| rewrite_expression(e, subs)).collect(),
        ),
        Statement::RevertNamedArgs(loc, path, args) => {
            let rewritten_args: Vec<NamedArgument> = args
                .iter()
                .map(|arg| NamedArgument {
                    loc: arg.loc,
                    name: arg.name.clone(),
                    expr: rewrite_expression(&arg.expr, subs),
                })
                .collect();
            Statement::RevertNamedArgs(*loc, path.clone(), rewritten_args)
        }
        Statement::Emit(loc, expr) => Statement::Emit(*loc, rewrite_expression(expr, subs)),
        Statement::Try(loc, expr, handler, catches) => Statement::Try(
            *loc,
            rewrite_expression(expr, subs),
            handler.as_ref().map(|(params, stmt)| {
                (
                    params.clone(),
                    Box::new(rewrite_statement(stmt, subs, placeholder_body)),
                )
            }),
            catches
                .iter()
                .map(|clause| match clause {
                    CatchClause::Simple(loc, param, stmt) => CatchClause::Simple(
                        *loc,
                        param.clone(),
                        rewrite_statement(stmt, subs, placeholder_body),
                    ),
                    CatchClause::Named(loc, path, param, stmt) => CatchClause::Named(
                        *loc,
                        path.clone(),
                        param.clone(),
                        rewrite_statement(stmt, subs, placeholder_body),
                    ),
                })
                .collect(),
        ),
        Statement::Error(_) => stmt.clone(),
    }
}