leo_passes/const_propagation/
program.rs

1// Copyright (C) 2019-2025 Provable Inc.
2// This file is part of the Leo library.
3
4// The Leo library is free software: you can redistribute it and/or modify
5// it under the terms of the GNU General Public License as published by
6// the Free Software Foundation, either version 3 of the License, or
7// (at your option) any later version.
8
9// The Leo library is distributed in the hope that it will be useful,
10// but WITHOUT ANY WARRANTY; without even the implied warranty of
11// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12// GNU General Public License for more details.
13
14// You should have received a copy of the GNU General Public License
15// along with the Leo library. If not, see <https://www.gnu.org/licenses/>.
16
17use super::ConstPropagationVisitor;
18
19use leo_ast::{
20    AstReconstructor as _,
21    ConstParameter,
22    Constructor,
23    Function,
24    Input,
25    Module,
26    Node,
27    Output,
28    ProgramReconstructor,
29    ProgramScope,
30    Statement,
31};
32
33impl ProgramReconstructor for ConstPropagationVisitor<'_> {
34    fn reconstruct_program_scope(&mut self, mut input: ProgramScope) -> ProgramScope {
35        self.program = input.program_id.name.name;
36
37        for (_sym, c) in input.consts.iter_mut() {
38            let Statement::Const(declaration) = self.reconstruct_const(std::mem::take(c)).0 else {
39                panic!("`reconstruct_const` always returns `Statement::Const`");
40            };
41            *c = declaration;
42        }
43
44        for (_sym, f) in input.functions.iter_mut() {
45            *f = self.reconstruct_function(std::mem::take(f));
46        }
47
48        if let Some(c) = input.constructor.as_mut() {
49            *c = self.reconstruct_constructor(std::mem::take(c));
50        }
51
52        input.structs = input.structs.into_iter().map(|(i, c)| (i, self.reconstruct_struct(c))).collect();
53        input.mappings =
54            input.mappings.into_iter().map(|(id, mapping)| (id, self.reconstruct_mapping(mapping))).collect();
55        input.storage_variables =
56            input.storage_variables.into_iter().map(|(id, var)| (id, self.reconstruct_storage_variable(var))).collect();
57
58        input
59    }
60
61    fn reconstruct_module(&mut self, input: Module) -> Module {
62        self.program = input.program_name;
63        self.in_module_scope(&input.path.clone(), |slf| {
64            Module {
65                // Reconstruct consts firsts
66                consts: input
67                    .consts
68                    .into_iter()
69                    .map(|(i, c)| match slf.reconstruct_const(c) {
70                        (Statement::Const(declaration), _) => (i, declaration),
71                        _ => panic!("`reconstruct_const` can only return `Statement::Const`"),
72                    })
73                    .collect(),
74                program_name: input.program_name,
75                path: input.path,
76                structs: input.structs.into_iter().map(|(i, c)| (i, slf.reconstruct_struct(c))).collect(),
77                functions: input.functions.into_iter().map(|(i, f)| (i, slf.reconstruct_function(f))).collect(),
78            }
79        })
80    }
81
82    fn reconstruct_function(&mut self, mut function: Function) -> Function {
83        self.in_scope(function.id(), |slf| {
84            function.const_parameters = function
85                .const_parameters
86                .iter()
87                .map(|param| ConstParameter { type_: slf.reconstruct_type(param.type_.clone()).0, ..param.clone() })
88                .collect();
89            function.input = function
90                .input
91                .iter()
92                .map(|input| Input { type_: slf.reconstruct_type(input.type_.clone()).0, ..input.clone() })
93                .collect();
94            function.output = function
95                .output
96                .iter()
97                .map(|output| Output { type_: slf.reconstruct_type(output.type_.clone()).0, ..output.clone() })
98                .collect();
99            function.output_type = slf.reconstruct_type(function.output_type).0;
100            function.block = slf.reconstruct_block(function.block).0;
101            function
102        })
103    }
104
105    fn reconstruct_constructor(&mut self, mut constructor: Constructor) -> Constructor {
106        self.in_scope(constructor.id(), |slf| {
107            constructor.block = slf.reconstruct_block(constructor.block).0;
108            constructor
109        })
110    }
111}
leo_passes/const_propagation/program.rs

leo_passes/const_propagation/
program.rs
