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

use log::debug;
use rue_ast::{AstConstantItem, AstNode};
use rue_diagnostic::DiagnosticKind;
use rue_hir::{ConstantSymbol, Declaration, Symbol, SymbolId, Value};

use crate::{Compiler, CompletionContext, SyntaxItemKind, compile_expr, compile_type};

pub fn declare_constant(ctx: &mut Compiler, constant: &AstConstantItem) -> SymbolId {
    ctx.add_syntax(
        SyntaxItemKind::CompletionContext(CompletionContext::Item),
        constant.syntax().text_range(),
    );

    let symbol = ctx.alloc_symbol(Symbol::Unresolved);

    ctx.push_declaration(Declaration::Symbol(symbol));

    let ty = if let Some(ty) = constant.ty() {
        compile_type(ctx, &ty)
    } else {
        debug!("Unresolved constant type");
        ctx.builtins().unresolved.ty
    };

    let value = ctx.builtins().unresolved.hir;

    let name = constant.name().map(|name| ctx.local_name(&name));

    *ctx.symbol_mut(symbol) = Symbol::Constant(ConstantSymbol {
        name,
        value: Value::new(value, ty),
        inline: constant.inline().is_some(),
    });

    if let Some(name) = constant.name() {
        if ctx.last_scope().symbol(name.text()).is_some() {
            ctx.diagnostic(
                &name,
                DiagnosticKind::DuplicateSymbol(name.text().to_string()),
            );
        } else {
            ctx.last_scope_mut().insert_symbol(
                name.text().to_string(),
                symbol,
                constant.export().is_some(),
            );
        }

        ctx.declaration_span(Declaration::Symbol(symbol), name.text_range());
    }

    ctx.pop_declaration();

    symbol
}

pub fn compile_constant(ctx: &mut Compiler, constant: &AstConstantItem, symbol: SymbolId) {
    ctx.push_declaration(Declaration::Symbol(symbol));

    let ty = if let Symbol::Constant(ConstantSymbol { value, .. }) = ctx.symbol(symbol) {
        value.ty
    } else {
        unreachable!();
    };

    let resolved_value = if let Some(expr) = constant.value() {
        let value = compile_expr(ctx, &expr, Some(ty));
        ctx.assign_type(expr.syntax(), value.ty, ty);
        value
    } else {
        debug!("Unresolved constant value");
        ctx.builtins().unresolved.clone()
    };

    let Symbol::Constant(ConstantSymbol { value, .. }) = ctx.symbol_mut(symbol) else {
        unreachable!();
    };

    *value = resolved_value.with_type(ty);

    ctx.pop_declaration();
}