rue_compiler/compile/
document.rs

1use rue_ast::{AstItem, AstSymbolItem};
2use rue_hir::ModuleDeclarations;
3
4use crate::{
5    Compiler, compile_module_symbols, compile_module_types, compile_symbol_item, compile_type_item,
6    declare_import_item, declare_module, declare_module_symbols, declare_module_types,
7    declare_symbol_item, declare_type_item,
8};
9
10pub fn declare_module_items(
11    ctx: &mut Compiler,
12    items: impl Iterator<Item = AstItem>,
13    declarations: &mut ModuleDeclarations,
14) {
15    for item in items {
16        match item {
17            AstItem::SymbolItem(AstSymbolItem::ModuleItem(item)) => {
18                declarations.modules.push(declare_module(ctx, &item));
19            }
20            AstItem::ImportItem(import) => {
21                declare_import_item(ctx, &import);
22            }
23            _ => {}
24        }
25    }
26}
27
28pub fn declare_type_items(
29    ctx: &mut Compiler,
30    items: impl Iterator<Item = AstItem>,
31    declarations: &mut ModuleDeclarations,
32) {
33    let mut module = 0;
34
35    for item in items {
36        match item {
37            AstItem::TypeItem(item) => declarations.types.push(declare_type_item(ctx, &item)),
38            AstItem::SymbolItem(item) => {
39                if let AstSymbolItem::ModuleItem(item) = item {
40                    declare_module_types(ctx, &item, declarations.modules[module]);
41                    module += 1;
42                }
43            }
44            AstItem::ImportItem(_) => {}
45        }
46    }
47}
48
49pub fn declare_symbol_items(
50    ctx: &mut Compiler,
51    items: impl Iterator<Item = AstItem>,
52    declarations: &mut ModuleDeclarations,
53) {
54    let mut module = 0;
55
56    for item in items {
57        match item {
58            AstItem::TypeItem(_) => {}
59            AstItem::SymbolItem(item) => {
60                if let AstSymbolItem::ModuleItem(item) = item {
61                    declare_module_symbols(ctx, &item, declarations.modules[module]);
62                    module += 1;
63                } else {
64                    declarations.symbols.push(declare_symbol_item(ctx, &item));
65                }
66            }
67            AstItem::ImportItem(_) => {}
68        }
69    }
70}
71
72pub fn compile_type_items(
73    ctx: &mut Compiler,
74    items: impl Iterator<Item = AstItem>,
75    declarations: &ModuleDeclarations,
76) {
77    let mut index = 0;
78    let mut module = 0;
79
80    for item in items {
81        match item {
82            AstItem::TypeItem(item) => {
83                let (ty, scope) = declarations.types[index];
84                compile_type_item(ctx, &item, ty, scope);
85                index += 1;
86            }
87            AstItem::SymbolItem(item) => {
88                if let AstSymbolItem::ModuleItem(item) = item {
89                    compile_module_types(ctx, &item, declarations.modules[module]);
90                    module += 1;
91                }
92            }
93            AstItem::ImportItem(_) => {}
94        }
95    }
96}
97
98pub fn compile_symbol_items(
99    ctx: &mut Compiler,
100    items: impl Iterator<Item = AstItem>,
101    declarations: &ModuleDeclarations,
102) {
103    let mut index = 0;
104    let mut module = 0;
105
106    for item in items {
107        match item {
108            AstItem::TypeItem(_) => {}
109            AstItem::SymbolItem(item) => {
110                if let AstSymbolItem::ModuleItem(item) = item {
111                    compile_module_symbols(ctx, &item, declarations.modules[module]);
112                    module += 1;
113                } else {
114                    let symbol = declarations.symbols[index];
115                    compile_symbol_item(ctx, &item, symbol);
116                    index += 1;
117                }
118            }
119            AstItem::ImportItem(_) => {}
120        }
121    }
122}
rue_compiler/compile/document.rs

rue_compiler/compile/
document.rs
