rue-compiler 0.8.4

A compiler for the Rue programming 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 rue_ast::{AstItem, AstSymbolItem};
use rue_hir::ModuleDeclarations;

use crate::{
    Compiler, compile_module_symbols, compile_module_types, compile_symbol_item, compile_type_item,
    declare_import_item, declare_module, declare_module_symbols, declare_module_types,
    declare_symbol_item, declare_type_item,
};

pub fn declare_module_items(
    ctx: &mut Compiler,
    items: impl Iterator<Item = AstItem>,
    declarations: &mut ModuleDeclarations,
) {
    for item in items {
        match item {
            AstItem::SymbolItem(AstSymbolItem::ModuleItem(item)) => {
                declarations.modules.push(declare_module(ctx, &item));
            }
            AstItem::ImportItem(import) => {
                declare_import_item(ctx, &import);
            }
            _ => {}
        }
    }
}

pub fn declare_type_items(
    ctx: &mut Compiler,
    items: impl Iterator<Item = AstItem>,
    declarations: &mut ModuleDeclarations,
) {
    let mut module = 0;

    for item in items {
        match item {
            AstItem::TypeItem(item) => declarations.types.push(declare_type_item(ctx, &item)),
            AstItem::SymbolItem(item) => {
                if let AstSymbolItem::ModuleItem(item) = item {
                    declare_module_types(ctx, &item, declarations.modules[module]);
                    module += 1;
                }
            }
            AstItem::ImportItem(_) => {}
        }
    }
}

pub fn declare_symbol_items(
    ctx: &mut Compiler,
    items: impl Iterator<Item = AstItem>,
    declarations: &mut ModuleDeclarations,
) {
    let mut module = 0;

    for item in items {
        match item {
            AstItem::TypeItem(_) => {}
            AstItem::SymbolItem(item) => {
                if let AstSymbolItem::ModuleItem(item) = item {
                    declare_module_symbols(ctx, &item, declarations.modules[module]);
                    module += 1;
                } else {
                    declarations.symbols.push(declare_symbol_item(ctx, &item));
                }
            }
            AstItem::ImportItem(_) => {}
        }
    }
}

pub fn compile_type_items(
    ctx: &mut Compiler,
    items: impl Iterator<Item = AstItem>,
    declarations: &ModuleDeclarations,
) {
    let mut index = 0;
    let mut module = 0;

    for item in items {
        match item {
            AstItem::TypeItem(item) => {
                let (ty, scope) = declarations.types[index];
                compile_type_item(ctx, &item, ty, scope);
                index += 1;
            }
            AstItem::SymbolItem(item) => {
                if let AstSymbolItem::ModuleItem(item) = item {
                    compile_module_types(ctx, &item, declarations.modules[module]);
                    module += 1;
                }
            }
            AstItem::ImportItem(_) => {}
        }
    }
}

pub fn compile_symbol_items(
    ctx: &mut Compiler,
    items: impl Iterator<Item = AstItem>,
    declarations: &ModuleDeclarations,
) {
    let mut index = 0;
    let mut module = 0;

    for item in items {
        match item {
            AstItem::TypeItem(_) => {}
            AstItem::SymbolItem(item) => {
                if let AstSymbolItem::ModuleItem(item) = item {
                    compile_module_symbols(ctx, &item, declarations.modules[module]);
                    module += 1;
                } else {
                    let symbol = declarations.symbols[index];
                    compile_symbol_item(ctx, &item, symbol);
                    index += 1;
                }
            }
            AstItem::ImportItem(_) => {}
        }
    }
}