snarkvm_synthesizer_program/
parse.rs

1// Copyright (c) 2019-2025 Provable Inc.
2// This file is part of the snarkVM library.
3
4// Licensed under the Apache License, Version 2.0 (the "License");
5// you may not use this file except in compliance with the License.
6// You may obtain a copy of the License at:
7
8// http://www.apache.org/licenses/LICENSE-2.0
9
10// Unless required by applicable law or agreed to in writing, software
11// distributed under the License is distributed on an "AS IS" BASIS,
12// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13// See the License for the specific language governing permissions and
14// limitations under the License.
15
16use super::*;
17
18impl<N: Network> Parser for ProgramCore<N> {
19    /// Parses a string into a program.
20    #[inline]
21    fn parse(string: &str) -> ParserResult<Self> {
22        // A helper to parse a program.
23        enum P<N: Network> {
24            Constructor(ConstructorCore<N>),
25            M(Mapping<N>),
26            S(StructType<N>),
27            R(RecordType<N>),
28            C(ClosureCore<N>),
29            F(FunctionCore<N>),
30        }
31
32        // Parse the imports from the string.
33        let (string, imports) = many0(Import::parse)(string)?;
34        // Parse the whitespace and comments from the string.
35        let (string, _) = Sanitizer::parse(string)?;
36        // Parse the 'program' keyword from the string.
37        let (string, _) = tag(Self::type_name())(string)?;
38        // Parse the whitespace from the string.
39        let (string, _) = Sanitizer::parse_whitespaces(string)?;
40        // Parse the program ID from the string.
41        let (string, id) = ProgramID::parse(string)?;
42        // Parse the whitespace from the string.
43        let (string, _) = Sanitizer::parse_whitespaces(string)?;
44        // Parse the semicolon ';' keyword from the string.
45        let (string, _) = tag(";")(string)?;
46
47        fn intermediate<N: Network>(string: &str) -> ParserResult<P<N>> {
48            // Parse the whitespace and comments from the string.
49            let (string, _) = Sanitizer::parse(string)?;
50
51            if string.starts_with(ConstructorCore::<N>::type_name()) {
52                map(ConstructorCore::parse, |constructor| P::<N>::Constructor(constructor))(string)
53            } else if string.starts_with(Mapping::<N>::type_name()) {
54                map(Mapping::parse, |mapping| P::<N>::M(mapping))(string)
55            } else if string.starts_with(StructType::<N>::type_name()) {
56                map(StructType::parse, |struct_| P::<N>::S(struct_))(string)
57            } else if string.starts_with(RecordType::<N>::type_name()) {
58                map(RecordType::parse, |record| P::<N>::R(record))(string)
59            } else if string.starts_with(ClosureCore::<N>::type_name()) {
60                map(ClosureCore::parse, |closure| P::<N>::C(closure))(string)
61            } else if string.starts_with(FunctionCore::<N>::type_name()) {
62                map(FunctionCore::parse, |function| P::<N>::F(function))(string)
63            } else {
64                Err(Err::Error(make_error(string, ErrorKind::Alt)))
65            }
66        }
67
68        // Parse the struct or function from the string.
69        let (string, components) = many1(intermediate)(string)?;
70        // Parse the whitespace and comments from the string.
71        let (string, _) = Sanitizer::parse(string)?;
72
73        // Initialize a new program.
74        let mut program = match ProgramCore::<N>::new(id) {
75            Ok(program) => program,
76            Err(error) => {
77                eprintln!("{error}");
78                return map_res(take(0usize), Err)(string);
79            }
80        };
81        // Construct the program with the parsed components.
82        for component in components {
83            let result = match component {
84                P::Constructor(constructor) => program.add_constructor(constructor),
85                P::M(mapping) => program.add_mapping(mapping),
86                P::S(struct_) => program.add_struct(struct_),
87                P::R(record) => program.add_record(record),
88                P::C(closure) => program.add_closure(closure),
89                P::F(function) => program.add_function(function),
90            };
91
92            match result {
93                Ok(_) => (),
94                Err(error) => {
95                    eprintln!("{error}");
96                    return map_res(take(0usize), Err)(string);
97                }
98            }
99        }
100        // Lastly, add the imports (if any) to the program.
101        for import in imports {
102            match program.add_import(import) {
103                Ok(_) => (),
104                Err(error) => {
105                    eprintln!("{error}");
106                    return map_res(take(0usize), Err)(string);
107                }
108            }
109        }
110
111        Ok((string, program))
112    }
113}
114
115impl<N: Network> FromStr for ProgramCore<N> {
116    type Err = Error;
117
118    /// Returns a program from a string literal.
119    fn from_str(string: &str) -> Result<Self> {
120        // Ensure the raw program string is less than MAX_PROGRAM_SIZE.
121        ensure!(string.len() <= N::MAX_PROGRAM_SIZE, "Program length exceeds N::MAX_PROGRAM_SIZE.");
122
123        match Self::parse(string) {
124            Ok((remainder, object)) => {
125                // Ensure the remainder is empty.
126                ensure!(remainder.is_empty(), "Failed to parse string. Remaining invalid string is: \"{remainder}\"");
127                // Return the object.
128                Ok(object)
129            }
130            Err(error) => bail!("Failed to parse string. {error}"),
131        }
132    }
133}
134
135impl<N: Network> Debug for ProgramCore<N> {
136    /// Prints the program as a string.
137    fn fmt(&self, f: &mut Formatter) -> fmt::Result {
138        Display::fmt(self, f)
139    }
140}
141
142impl<N: Network> Display for ProgramCore<N> {
143    /// Prints the program as a string.
144    fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
145        if !self.imports.is_empty() {
146            // Print the imports.
147            for import in self.imports.values() {
148                writeln!(f, "{import}")?;
149            }
150
151            // Print a newline.
152            writeln!(f)?;
153        }
154
155        // Print the program name.
156        write!(f, "{} {};\n\n", Self::type_name(), self.id)?;
157
158        // Write the components.
159        let mut components_iter = self.components.iter().peekable();
160        while let Some((label, definition)) = components_iter.next() {
161            match label {
162                ProgramLabel::Constructor => {
163                    // Write the constructor, if it exists.
164                    if let Some(constructor) = &self.constructor {
165                        writeln!(f, "{constructor}")?;
166                    }
167                }
168                ProgramLabel::Identifier(identifier) => match definition {
169                    ProgramDefinition::Constructor => return Err(fmt::Error),
170                    ProgramDefinition::Mapping => match self.mappings.get(identifier) {
171                        Some(mapping) => writeln!(f, "{mapping}")?,
172                        None => return Err(fmt::Error),
173                    },
174                    ProgramDefinition::Struct => match self.structs.get(identifier) {
175                        Some(struct_) => writeln!(f, "{struct_}")?,
176                        None => return Err(fmt::Error),
177                    },
178                    ProgramDefinition::Record => match self.records.get(identifier) {
179                        Some(record) => writeln!(f, "{record}")?,
180                        None => return Err(fmt::Error),
181                    },
182                    ProgramDefinition::Closure => match self.closures.get(identifier) {
183                        Some(closure) => writeln!(f, "{closure}")?,
184                        None => return Err(fmt::Error),
185                    },
186                    ProgramDefinition::Function => match self.functions.get(identifier) {
187                        Some(function) => writeln!(f, "{function}")?,
188                        None => return Err(fmt::Error),
189                    },
190                },
191            }
192
193            // Omit the last newline.
194            if components_iter.peek().is_some() {
195                writeln!(f)?;
196            }
197        }
198
199        Ok(())
200    }
201}
202
203#[cfg(test)]
204mod tests {
205    use super::*;
206    use crate::Program;
207    use console::network::MainnetV0;
208
209    type CurrentNetwork = MainnetV0;
210
211    #[test]
212    fn test_program_parse() -> Result<()> {
213        // Initialize a new program.
214        let (string, program) = Program::<CurrentNetwork>::parse(
215            r"
216program to_parse.aleo;
217
218struct message:
219    first as field;
220    second as field;
221
222function compute:
223    input r0 as message.private;
224    add r0.first r0.second into r1;
225    output r1 as field.private;",
226        )
227        .unwrap();
228        assert!(string.is_empty(), "Parser did not consume all of the string: '{string}'");
229
230        // Ensure the program contains the struct.
231        assert!(program.contains_struct(&Identifier::from_str("message")?));
232        // Ensure the program contains the function.
233        assert!(program.contains_function(&Identifier::from_str("compute")?));
234
235        Ok(())
236    }
237
238    #[test]
239    fn test_program_parse_function_zero_inputs() -> Result<()> {
240        // Initialize a new program.
241        let (string, program) = Program::<CurrentNetwork>::parse(
242            r"
243program to_parse.aleo;
244
245function compute:
246    add 1u32 2u32 into r0;
247    output r0 as u32.private;",
248        )
249        .unwrap();
250        assert!(string.is_empty(), "Parser did not consume all of the string: '{string}'");
251
252        // Ensure the program contains the function.
253        assert!(program.contains_function(&Identifier::from_str("compute")?));
254
255        Ok(())
256    }
257
258    #[test]
259    fn test_program_display() -> Result<()> {
260        let expected = r"program to_parse.aleo;
261
262struct message:
263    first as field;
264    second as field;
265
266function compute:
267    input r0 as message.private;
268    add r0.first r0.second into r1;
269    output r1 as field.private;
270";
271        // Parse a new program.
272        let program = Program::<CurrentNetwork>::from_str(expected)?;
273        // Ensure the program string matches.
274        assert_eq!(expected, format!("{program}"));
275
276        Ok(())
277    }
278
279    #[test]
280    fn test_program_size() {
281        // Define variable name for easy experimentation with program sizes.
282        let var_name = "a";
283
284        // Helper function to generate imports.
285        let gen_import_string = |n: usize| -> String {
286            let mut s = String::new();
287            for i in 0..n {
288                s.push_str(&format!("import foo{i}.aleo;\n"));
289            }
290            s
291        };
292
293        // Helper function to generate large structs.
294        let gen_struct_string = |n: usize| -> String {
295            let mut s = String::with_capacity(CurrentNetwork::MAX_PROGRAM_SIZE);
296            for i in 0..n {
297                s.push_str(&format!("struct m{i}:\n"));
298                for j in 0..10 {
299                    s.push_str(&format!("    {var_name}{j} as u128;\n"));
300                }
301            }
302            s
303        };
304
305        // Helper function to generate large records.
306        let gen_record_string = |n: usize| -> String {
307            let mut s = String::with_capacity(CurrentNetwork::MAX_PROGRAM_SIZE);
308            for i in 0..n {
309                s.push_str(&format!("record r{i}:\n    owner as address.private;\n"));
310                for j in 0..10 {
311                    s.push_str(&format!("    {var_name}{j} as u128.private;\n"));
312                }
313            }
314            s
315        };
316
317        // Helper function to generate large mappings.
318        let gen_mapping_string = |n: usize| -> String {
319            let mut s = String::with_capacity(CurrentNetwork::MAX_PROGRAM_SIZE);
320            for i in 0..n {
321                s.push_str(&format!("mapping {var_name}{i}:\n    key as field.public;\n    value as field.public;\n"));
322            }
323            s
324        };
325
326        // Helper function to generate large closures.
327        let gen_closure_string = |n: usize| -> String {
328            let mut s = String::with_capacity(CurrentNetwork::MAX_PROGRAM_SIZE);
329            for i in 0..n {
330                s.push_str(&format!("closure c{i}:\n    input r0 as u128;\n"));
331                for j in 0..10 {
332                    s.push_str(&format!("    add r0 r0 into r{j};\n"));
333                }
334                s.push_str(&format!("    output r{} as u128;\n", 4000));
335            }
336            s
337        };
338
339        // Helper function to generate large functions.
340        let gen_function_string = |n: usize| -> String {
341            let mut s = String::with_capacity(CurrentNetwork::MAX_PROGRAM_SIZE);
342            for i in 0..n {
343                s.push_str(&format!("function f{i}:\n    add 1u128 1u128 into r0;\n"));
344                for j in 0..10 {
345                    s.push_str(&format!("    add r0 r0 into r{j};\n"));
346                }
347            }
348            s
349        };
350
351        // Helper function to generate and parse a program.
352        let test_parse = |imports: &str, body: &str, should_succeed: bool| {
353            let program = format!("{imports}\nprogram to_parse.aleo;\n\n{body}");
354            let result = Program::<CurrentNetwork>::from_str(&program);
355            if result.is_ok() != should_succeed {
356                println!("Program failed to parse: {program}");
357            }
358            assert_eq!(result.is_ok(), should_succeed);
359        };
360
361        // A program with MAX_IMPORTS should succeed.
362        test_parse(&gen_import_string(CurrentNetwork::MAX_IMPORTS), &gen_struct_string(1), true);
363        // A program with more than MAX_IMPORTS should fail.
364        test_parse(&gen_import_string(CurrentNetwork::MAX_IMPORTS + 1), &gen_struct_string(1), false);
365        // A program with MAX_STRUCTS should succeed.
366        test_parse("", &gen_struct_string(CurrentNetwork::MAX_STRUCTS), true);
367        // A program with more than MAX_STRUCTS should fail.
368        test_parse("", &gen_struct_string(CurrentNetwork::MAX_STRUCTS + 1), false);
369        // A program with MAX_RECORDS should succeed.
370        test_parse("", &gen_record_string(CurrentNetwork::MAX_RECORDS), true);
371        // A program with more than MAX_RECORDS should fail.
372        test_parse("", &gen_record_string(CurrentNetwork::MAX_RECORDS + 1), false);
373        // A program with MAX_MAPPINGS should succeed.
374        test_parse("", &gen_mapping_string(CurrentNetwork::MAX_MAPPINGS), true);
375        // A program with more than MAX_MAPPINGS should fail.
376        test_parse("", &gen_mapping_string(CurrentNetwork::MAX_MAPPINGS + 1), false);
377        // A program with MAX_CLOSURES should succeed.
378        test_parse("", &gen_closure_string(CurrentNetwork::MAX_CLOSURES), true);
379        // A program with more than MAX_CLOSURES should fail.
380        test_parse("", &gen_closure_string(CurrentNetwork::MAX_CLOSURES + 1), false);
381        // A program with MAX_FUNCTIONS should succeed.
382        test_parse("", &gen_function_string(CurrentNetwork::MAX_FUNCTIONS), true);
383        // A program with more than MAX_FUNCTIONS should fail.
384        test_parse("", &gen_function_string(CurrentNetwork::MAX_FUNCTIONS + 1), false);
385
386        // Initialize a program which is too big.
387        let program_too_big = format!(
388            "{} {} {} {} {}",
389            gen_struct_string(CurrentNetwork::MAX_STRUCTS),
390            gen_record_string(CurrentNetwork::MAX_RECORDS),
391            gen_mapping_string(CurrentNetwork::MAX_MAPPINGS),
392            gen_closure_string(CurrentNetwork::MAX_CLOSURES),
393            gen_function_string(CurrentNetwork::MAX_FUNCTIONS)
394        );
395        // A program which is too big should fail.
396        test_parse("", &program_too_big, false);
397    }
398}
snarkvm_synthesizer_program/parse.rs

snarkvm_synthesizer_program/
parse.rs
