circomspect_program_structure/control_flow_graph/
parameters.rs

1use crate::ast::Definition;
2use crate::file_definition::{FileID, FileLocation};
3use crate::function_data::FunctionData;
4use crate::template_data::TemplateData;
5
6use crate::ir::VariableName;
7
8pub struct Parameters {
9    param_names: Vec<VariableName>,
10    file_id: Option<FileID>,
11    file_location: FileLocation,
12}
13
14impl Parameters {
15    #[must_use]
16    pub fn new(
17        param_names: &[String],
18        file_id: Option<FileID>,
19        file_location: FileLocation,
20    ) -> Parameters {
21        Parameters {
22            param_names: param_names.iter().map(VariableName::from_string).collect(),
23            file_id,
24            file_location,
25        }
26    }
27
28    #[must_use]
29    pub fn file_id(&self) -> &Option<FileID> {
30        &self.file_id
31    }
32
33    #[must_use]
34    pub fn file_location(&self) -> &FileLocation {
35        &self.file_location
36    }
37
38    #[must_use]
39    pub fn len(&self) -> usize {
40        self.param_names.len()
41    }
42
43    #[must_use]
44    pub fn is_empty(&self) -> bool {
45        self.len() == 0
46    }
47
48    pub fn iter(&self) -> impl Iterator<Item = &VariableName> {
49        self.param_names.iter()
50    }
51
52    pub fn iter_mut(&mut self) -> impl Iterator<Item = &mut VariableName> {
53        self.param_names.iter_mut()
54    }
55
56    pub fn contains(&self, param_name: &VariableName) -> bool {
57        self.param_names.contains(param_name)
58    }
59}
60
61impl From<&FunctionData> for Parameters {
62    fn from(function: &FunctionData) -> Parameters {
63        Parameters::new(
64            function.get_name_of_params(),
65            Some(function.get_file_id()),
66            function.get_param_location(),
67        )
68    }
69}
70
71impl From<&TemplateData> for Parameters {
72    fn from(template: &TemplateData) -> Parameters {
73        Parameters::new(
74            template.get_name_of_params(),
75            Some(template.get_file_id()),
76            template.get_param_location(),
77        )
78    }
79}
80
81impl From<&Definition> for Parameters {
82    fn from(definition: &Definition) -> Parameters {
83        match definition {
84            Definition::Function { meta, args, arg_location, .. }
85            | Definition::Template { meta, args, arg_location, .. } => {
86                Parameters::new(args, meta.file_id, arg_location.clone())
87            }
88        }
89    }
90}