Skip to main content

nu_protocol/
module.rs

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    /// TODO: for referencing module name as a record, e.g. `$module_name.const_name`
14    /// values got multiple duplicates in memory.
15    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/// Collection of definitions that can be exported from a module
38#[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>, // `export-env { ... }` block
46    pub main: Option<DeclId>,       // `export def main`
47    pub span: Option<Span>,
48    pub imported_modules: Vec<ModuleId>, // use other_module.nu
49    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    /// Resolve `members` from given module, which is indicated by `self_id` to import.
122    ///
123    /// When resolving, all modules are recorded in `imported_modules`.
124    pub fn resolve_import_pattern(
125        &self,
126        working_set: &StateWorkingSet,
127        self_id: ModuleId,
128        members: &[ImportPatternMember],
129        name_override: Option<&[u8]>, // name under the module was stored (doesn't have to be the same as self.name)
130        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            // Import pattern was just name without any members
140            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            // only needs to bring `$module` with a record value if it defines any constants.
156            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                // A type alias name can't take the `module ` prefix, so a bare import brings in
173                // no type aliases.
174                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                // raise errors if user wants to do something like this:
188                // `use a b c`: but b is not a sub-module of a.
189                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                // Types and commands are separate namespaces, so the name can be a type alias as
202                // well as a command, constant or submodule. Importing it brings in both, and it's
203                // only missing when it matches no export of any kind.
204                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                    // As for a single name, a type alias is looked up separately.
356                    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
497/// normalize module names for exporting as record constant
498fn 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}