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
use super::ast::Definition;
use super::report_code::ReportCode;
use super::report::Report;
use super::file_definition::FileID;
use super::function_data::{FunctionData, FunctionInfo};
use super::template_data::{TemplateData, TemplateInfo};
#[derive(Default)]
pub struct Merger {
fresh_id: usize,
function_info: FunctionInfo,
template_info: TemplateInfo,
}
impl Merger {
pub fn new() -> Merger {
Merger::default()
}
pub fn add_definitions(
&mut self,
file_id: FileID,
definitions: &Vec<Definition>,
) -> Result<(), Vec<Report>> {
let mut reports = vec![];
for definition in definitions {
let (name, meta) = match definition {
Definition::Template {
name,
args,
arg_location,
body,
meta,
parallel,
is_custom_gate,
} => {
if self.contains_function(name) || self.contains_template(name) {
(Option::Some(name), meta)
} else {
let new_data = TemplateData::new(
name.clone(),
file_id,
body.clone(),
args.len(),
args.clone(),
arg_location.clone(),
&mut self.fresh_id,
*parallel,
*is_custom_gate,
);
self.get_mut_template_info().insert(name.clone(), new_data);
(Option::None, meta)
}
}
Definition::Function { name, body, args, arg_location, meta } => {
if self.contains_function(name) || self.contains_template(name) {
(Option::Some(name), meta)
} else {
let new_data = FunctionData::new(
name.clone(),
file_id,
body.clone(),
args.len(),
args.clone(),
arg_location.clone(),
&mut self.fresh_id,
);
self.get_mut_function_info().insert(name.clone(), new_data);
(Option::None, meta)
}
}
};
if let Option::Some(definition_name) = name {
let mut report = Report::error(
String::from("Duplicated function or template."),
ReportCode::SameSymbolDeclaredTwice,
);
report.add_primary(
meta.file_location(),
file_id,
format!("The name `{definition_name}` is already used."),
);
reports.push(report);
}
}
if reports.is_empty() {
Ok(())
} else {
Err(reports)
}
}
pub fn contains_function(&self, function_name: &str) -> bool {
self.get_function_info().contains_key(function_name)
}
fn get_function_info(&self) -> &FunctionInfo {
&self.function_info
}
fn get_mut_function_info(&mut self) -> &mut FunctionInfo {
&mut self.function_info
}
pub fn contains_template(&self, template_name: &str) -> bool {
self.get_template_info().contains_key(template_name)
}
fn get_template_info(&self) -> &TemplateInfo {
&self.template_info
}
fn get_mut_template_info(&mut self) -> &mut TemplateInfo {
&mut self.template_info
}
pub fn decompose(self) -> (usize, FunctionInfo, TemplateInfo) {
(self.fresh_id, self.function_info, self.template_info)
}
}