mod_language 0.1.22

WIP wasm scripting language
Documentation 
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
116
117
118
119
120
121
122

use crate::{
  common::{ Identifier, },
  ast::{ Item, ItemData, ExportData, },
  ctx::{ GlobalKey, Module, Global, Function, },
};

use super::{
  Analyzer,
  support_structures::{ Alias, AliasData, },
};



/// Binds top level items to their identifiers
pub fn bind_top_level (analyzer: &mut Analyzer, items: &[Item], aliases: &mut Vec<Alias>) {
  for item in items.iter() {
    match &item.data {
      ItemData::Import { data, .. } => {
        let destination_module = analyzer.get_active_module_key();

        for (base, new_name) in data.iter() {
          let new_name = if let Some(new_name) = new_name { new_name } else { base.last().expect("Internal error, empty import path with no alias") }.to_owned();
          
          let relative_to = if base.absolute { analyzer.context.lib_mod } else { destination_module };

          aliases.push(Alias {
            destination_module,
            data: AliasData::Import {
              absolute: base.absolute,
              relative_to,
              chain: base.chain.clone()
            },
            new_name,
            origin: item.origin,
          })
        }
      },

      ItemData::Export { data, .. } => {
        match data {
          ExportData::List(exports) => {
            let destination_module = analyzer.get_active_module_key();

            for (base, new_name) in exports.iter() {
              let new_name = if let Some(new_name) = new_name { new_name } else { base }.to_owned();
              
              aliases.push(Alias {
                destination_module,
                data: AliasData::Export { base: base.clone() },
                new_name,
                origin: item.origin,
              })
            }
          },

          ExportData::Inline(item) => {
            let (identifier, key) = bind_item(analyzer, item, aliases);

            analyzer.get_active_module_mut().export_bindings.set_entry_bound(identifier.to_owned(), key, item.origin);
          },
        }
      },

      | ItemData::Module   { .. }
      | ItemData::Global   { .. }
      | ItemData::Function { .. }
      => {
        bind_item(analyzer, item, aliases);
      }
    }
  }
}


fn bind_item<'a> (analyzer: &mut Analyzer, item: &'a Item, aliases: &mut Vec<Alias>) -> (&'a Identifier, GlobalKey) {
  match &item.data {
    ItemData::Module { identifier, items, .. } => {
      let new_mod = analyzer.create_item(
        identifier.to_owned(),
        Module::new(
          Some(analyzer.get_active_module_key()),
          identifier.to_owned(),
          item.origin
        ),
        item.origin
      );

      analyzer.push_active_module(new_mod);

      bind_top_level(analyzer, items, aliases);

      analyzer.pop_active_module();

      (identifier, new_mod)
    },

    ItemData::Global { identifier, .. } => (identifier, analyzer.create_item(
      identifier.to_owned(),
      Global::new(
        identifier.to_owned(),
        item.origin,
        None
      ),
      item.origin
    )),

    ItemData::Function { identifier, .. } => (identifier, analyzer.create_item(
      identifier.to_owned(),
      Function::new(
        identifier.to_owned(),
        item.origin,
        None
      ),
      item.origin
    )),

    | ItemData::Import { .. }
    | ItemData::Export { .. }
    => unreachable!("Internal error, export node contains invalid descendent")
  }
}