1use crate::{
2 BlockId, DeclId, FileId, ModuleId, ParseError, Span, TypeAliasId, Value, VarId,
3 ast::ImportPatternMember, engine::StateWorkingSet,
4};
5
6use crate::parser_path::ParserPath;
7use indexmap::IndexMap;
8
9pub struct ResolvedImportPattern {
10 pub decls: Vec<(Vec<u8>, DeclId)>,
11 pub modules: Vec<(Vec<u8>, ModuleId)>,
12 pub constants: Vec<(Vec<u8>, VarId)>,
13 pub constant_values: Vec<(Vec<u8>, Value)>,
16 pub type_aliases: Vec<(Vec<u8>, TypeAliasId)>,
17}
18
19impl ResolvedImportPattern {
20 pub fn new(
21 decls: Vec<(Vec<u8>, DeclId)>,
22 modules: Vec<(Vec<u8>, ModuleId)>,
23 constants: Vec<(Vec<u8>, VarId)>,
24 constant_values: Vec<(Vec<u8>, Value)>,
25 type_aliases: Vec<(Vec<u8>, TypeAliasId)>,
26 ) -> Self {
27 ResolvedImportPattern {
28 decls,
29 modules,
30 constants,
31 constant_values,
32 type_aliases,
33 }
34 }
35}
36
37#[derive(Debug, Clone)]
39pub struct Module {
40 pub name: Vec<u8>,
41 pub decls: IndexMap<Vec<u8>, DeclId>,
42 pub submodules: IndexMap<Vec<u8>, ModuleId>,
43 pub constants: IndexMap<Vec<u8>, VarId>,
44 pub type_aliases: IndexMap<Vec<u8>, TypeAliasId>,
45 pub env_block: Option<BlockId>, pub main: Option<DeclId>, pub span: Option<Span>,
48 pub imported_modules: Vec<ModuleId>, pub file: Option<(ParserPath, FileId)>,
50}
51
52impl Module {
53 pub fn new(name: Vec<u8>) -> Self {
54 Module {
55 name,
56 decls: IndexMap::new(),
57 submodules: IndexMap::new(),
58 constants: IndexMap::new(),
59 type_aliases: IndexMap::new(),
60 env_block: None,
61 main: None,
62 span: None,
63 imported_modules: vec![],
64 file: None,
65 }
66 }
67
68 pub fn from_span(name: Vec<u8>, span: Span) -> Self {
69 Module {
70 name,
71 decls: IndexMap::new(),
72 submodules: IndexMap::new(),
73 constants: IndexMap::new(),
74 type_aliases: IndexMap::new(),
75 env_block: None,
76 main: None,
77 span: Some(span),
78 imported_modules: vec![],
79 file: None,
80 }
81 }
82
83 pub fn name(&self) -> Vec<u8> {
84 self.name.clone()
85 }
86
87 pub fn add_decl(&mut self, name: Vec<u8>, decl_id: DeclId) -> Option<DeclId> {
88 self.decls.insert(name, decl_id)
89 }
90
91 pub fn add_submodule(&mut self, name: Vec<u8>, module_id: ModuleId) -> Option<ModuleId> {
92 self.submodules.insert(name, module_id)
93 }
94
95 pub fn add_variable(&mut self, name: Vec<u8>, var_id: VarId) -> Option<VarId> {
96 self.constants.insert(name, var_id)
97 }
98
99 pub fn add_type_alias(&mut self, name: Vec<u8>, type_alias_id: TypeAliasId) {
100 self.type_aliases.insert(name, type_alias_id);
101 }
102
103 pub fn add_env_block(&mut self, block_id: BlockId) {
104 self.env_block = Some(block_id);
105 }
106
107 pub fn track_imported_modules(&mut self, module_id: &[ModuleId]) {
108 for m in module_id {
109 self.imported_modules.push(*m)
110 }
111 }
112
113 pub fn has_decl(&self, name: &[u8]) -> bool {
114 if name == self.name && self.main.is_some() {
115 return true;
116 }
117
118 self.decls.contains_key(name)
119 }
120
121 pub fn resolve_import_pattern(
125 &self,
126 working_set: &StateWorkingSet,
127 self_id: ModuleId,
128 members: &[ImportPatternMember],
129 name_override: Option<&[u8]>, backup_span: Span,
131 imported_modules: &mut Vec<ModuleId>,
132 ) -> (ResolvedImportPattern, Vec<ParseError>) {
133 imported_modules.push(self_id);
134 let final_name = name_override.unwrap_or(&self.name).to_vec();
135
136 let (head, rest) = if let Some((head, rest)) = members.split_first() {
137 (head, rest)
138 } else {
139 let mut decls = vec![];
141 let mut const_rows = vec![];
142 let mut errors = vec![];
143
144 decls.extend(self.decls_with_head(&final_name));
145
146 for (name, var_id) in self.consts() {
147 match working_set.get_constant(var_id) {
148 Ok(const_val) => const_rows.push((name, const_val.clone())),
149 Err(err) => errors.push(err),
150 }
151 }
152
153 let span = self.span.unwrap_or(backup_span);
154
155 let constant_values = if const_rows.is_empty() {
157 vec![]
158 } else {
159 vec![(
160 normalize_module_name(&final_name),
161 Value::record(
162 const_rows
163 .into_iter()
164 .map(|(name, val)| (String::from_utf8_lossy(&name).to_string(), val))
165 .collect(),
166 span,
167 ),
168 )]
169 };
170
171 return (
172 ResolvedImportPattern::new(
175 decls,
176 vec![(final_name.clone(), self_id)],
177 vec![],
178 constant_values,
179 vec![],
180 ),
181 errors,
182 );
183 };
184
185 match head {
186 ImportPatternMember::Name { name, span } => {
187 let errors = if !rest.is_empty() && self.submodules.get(name).is_none() {
190 vec![ParseError::WrongImportPattern(
191 format!(
192 "Trying to import something but the parent `{}` is not a module, maybe you want to try `use <module> [<name1>, <name2>]`",
193 String::from_utf8_lossy(name)
194 ),
195 rest[0].span(),
196 )]
197 } else {
198 vec![]
199 };
200
201 let type_aliases: Vec<_> = self
205 .type_aliases
206 .get(name)
207 .map(|type_alias_id| (name.clone(), *type_alias_id))
208 .into_iter()
209 .collect();
210 let is_type_alias = !type_aliases.is_empty();
211 let not_found = move |errors| {
212 if is_type_alias {
213 errors
214 } else {
215 vec![ParseError::ExportNotFound(*span)]
216 }
217 };
218
219 if name == b"main" {
220 if let Some(main_decl_id) = self.main {
221 (
222 ResolvedImportPattern::new(
223 vec![(final_name, main_decl_id)],
224 vec![],
225 vec![],
226 vec![],
227 type_aliases,
228 ),
229 errors,
230 )
231 } else {
232 (
233 ResolvedImportPattern::new(
234 vec![],
235 vec![],
236 vec![],
237 vec![],
238 type_aliases,
239 ),
240 not_found(errors),
241 )
242 }
243 } else if let Some(decl_id) = self.decls.get(name) {
244 (
245 ResolvedImportPattern::new(
246 vec![(name.clone(), *decl_id)],
247 vec![],
248 vec![],
249 vec![],
250 type_aliases,
251 ),
252 errors,
253 )
254 } else if let Some(var_id) = self.constants.get(name) {
255 match working_set.get_constant(*var_id) {
256 Ok(_) => (
257 ResolvedImportPattern::new(
258 vec![],
259 vec![],
260 vec![(name.clone(), *var_id)],
261 vec![],
262 type_aliases,
263 ),
264 errors,
265 ),
266 Err(err) => (
267 ResolvedImportPattern::new(vec![], vec![], vec![], vec![], vec![]),
268 vec![err],
269 ),
270 }
271 } else if let Some(submodule_id) = self.submodules.get(name) {
272 let submodule = working_set.get_module(*submodule_id);
273 let (mut definitions, errors) = submodule.resolve_import_pattern(
274 working_set,
275 *submodule_id,
276 rest,
277 None,
278 self.span.unwrap_or(backup_span),
279 imported_modules,
280 );
281 if rest.is_empty() {
282 definitions.type_aliases.extend(type_aliases);
283 }
284 (definitions, errors)
285 } else {
286 (
287 ResolvedImportPattern::new(vec![], vec![], vec![], vec![], type_aliases),
288 not_found(errors),
289 )
290 }
291 }
292 ImportPatternMember::Glob { .. } => {
293 let mut decls = vec![];
294 let mut submodules = vec![];
295 let mut constants = vec![];
296 let mut constant_values = vec![];
297 let mut errors = vec![];
298
299 for (_, id) in &self.submodules {
300 let submodule = working_set.get_module(*id);
301 let (sub_results, sub_errors) = submodule.resolve_import_pattern(
302 working_set,
303 *id,
304 &[],
305 None,
306 self.span.unwrap_or(backup_span),
307 imported_modules,
308 );
309 decls.extend(sub_results.decls);
310
311 submodules.extend(sub_results.modules);
312 constants.extend(sub_results.constants);
313 constant_values.extend(sub_results.constant_values);
314 errors.extend(sub_errors);
315 }
316
317 decls.extend(self.decls());
318 for (name, var_id) in self.constants.iter() {
319 match working_set.get_constant(*var_id) {
320 Ok(_) => {
321 constants.push((name.clone(), *var_id));
322 }
323 Err(err) => {
324 errors.push(err);
325 }
326 }
327 }
328 submodules.extend(self.submodules());
329 let type_aliases = self
330 .type_aliases
331 .iter()
332 .map(|(name, type_alias_id)| (name.clone(), *type_alias_id))
333 .collect();
334
335 (
336 ResolvedImportPattern::new(
337 decls,
338 submodules,
339 constants,
340 constant_values,
341 type_aliases,
342 ),
343 errors,
344 )
345 }
346 ImportPatternMember::List { names } => {
347 let mut decls = vec![];
348 let mut modules = vec![];
349 let mut constants = vec![];
350 let mut constant_values = vec![];
351 let mut type_aliases = vec![];
352 let mut errors = vec![];
353
354 for (name, span) in names {
355 let type_alias = self.type_aliases.get(name);
357 if let Some(type_alias_id) = type_alias {
358 type_aliases.push((name.clone(), *type_alias_id));
359 }
360
361 if name == b"main" {
362 if let Some(main_decl_id) = self.main {
363 decls.push((final_name.clone(), main_decl_id));
364 } else if type_alias.is_none() {
365 errors.push(ParseError::ExportNotFound(*span));
366 }
367 } else if let Some(decl_id) = self.decls.get(name) {
368 decls.push((name.clone(), *decl_id));
369 } else if let Some(var_id) = self.constants.get(name) {
370 match working_set.get_constant(*var_id) {
371 Ok(_) => constants.push((name.clone(), *var_id)),
372 Err(err) => errors.push(err),
373 }
374 } else if let Some(submodule_id) = self.submodules.get(name) {
375 let submodule = working_set.get_module(*submodule_id);
376 let (sub_results, sub_errors) = submodule.resolve_import_pattern(
377 working_set,
378 *submodule_id,
379 rest,
380 None,
381 self.span.unwrap_or(backup_span),
382 imported_modules,
383 );
384
385 decls.extend(sub_results.decls);
386 modules.extend(sub_results.modules);
387 constants.extend(sub_results.constants);
388 constant_values.extend(sub_results.constant_values);
389 errors.extend(sub_errors);
390 } else if type_alias.is_none() {
391 errors.push(ParseError::ExportNotFound(*span));
392 }
393 }
394
395 (
396 ResolvedImportPattern::new(
397 decls,
398 modules,
399 constants,
400 constant_values,
401 type_aliases,
402 ),
403 errors,
404 )
405 }
406 }
407 }
408
409 pub fn decl_name_with_head(&self, name: &[u8], head: &[u8]) -> Option<Vec<u8>> {
410 if self.has_decl(name) {
411 let mut new_name = head.to_vec();
412 new_name.push(b' ');
413 new_name.extend(name);
414 Some(new_name)
415 } else {
416 None
417 }
418 }
419
420 pub fn decls_with_head(&self, head: &[u8]) -> Vec<(Vec<u8>, DeclId)> {
421 let mut result: Vec<(Vec<u8>, DeclId)> = self
422 .decls
423 .iter()
424 .map(|(name, id)| {
425 let mut new_name = head.to_vec();
426 new_name.push(b' ');
427 new_name.extend(name);
428 (new_name, *id)
429 })
430 .collect();
431
432 if let Some(decl_id) = self.main {
433 result.push((self.name.clone(), decl_id));
434 }
435
436 result
437 }
438
439 pub fn consts(&self) -> Vec<(Vec<u8>, VarId)> {
440 self.constants
441 .iter()
442 .map(|(name, id)| (name.to_vec(), *id))
443 .collect()
444 }
445
446 pub fn decl_names_with_head(&self, head: &[u8]) -> Vec<Vec<u8>> {
447 let mut result: Vec<Vec<u8>> = self
448 .decls
449 .keys()
450 .map(|name| {
451 let mut new_name = head.to_vec();
452 new_name.push(b' ');
453 new_name.extend(name);
454 new_name
455 })
456 .collect();
457
458 if self.main.is_some() {
459 result.push(self.name.clone());
460 }
461
462 result
463 }
464
465 pub fn decls(&self) -> Vec<(Vec<u8>, DeclId)> {
466 let mut result: Vec<(Vec<u8>, DeclId)> = self
467 .decls
468 .iter()
469 .map(|(name, id)| (name.clone(), *id))
470 .collect();
471
472 if let Some(decl_id) = self.main {
473 result.push((self.name.clone(), decl_id));
474 }
475
476 result
477 }
478
479 pub fn submodules(&self) -> Vec<(Vec<u8>, ModuleId)> {
480 self.submodules
481 .iter()
482 .map(|(name, id)| (name.clone(), *id))
483 .collect()
484 }
485
486 pub fn decl_names(&self) -> Vec<Vec<u8>> {
487 let mut result: Vec<Vec<u8>> = self.decls.keys().cloned().collect();
488
489 if self.main.is_some() {
490 result.push(self.name.clone());
491 }
492
493 result
494 }
495}
496
497fn normalize_module_name(bytes: &[u8]) -> Vec<u8> {
499 bytes
500 .iter()
501 .map(|x| match is_identifier_byte(*x) {
502 true => *x,
503 false => b'_',
504 })
505 .collect()
506}
507
508fn is_identifier_byte(b: u8) -> bool {
509 b != b'.'
510 && b != b'['
511 && b != b'('
512 && b != b'{'
513 && b != b'+'
514 && b != b'-'
515 && b != b'*'
516 && b != b'^'
517 && b != b'%'
518 && b != b'/'
519 && b != b'='
520 && b != b'!'
521 && b != b'<'
522 && b != b'>'
523 && b != b'&'
524 && b != b'|'
525}