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

use std::collections::HashSet;

use log::debug;
use rue_ast::{AstNode, AstStructBinding};
use rue_diagnostic::DiagnosticKind;
use rue_hir::{BindingSymbol, Declaration, Hir, Symbol, SymbolId, SymbolPath, Value};

use crate::{
    Compiler, CompletionContext, Field, FieldResult, SyntaxField, SyntaxItemKind, compile_field,
    create_binding, create_binding_for_identifier,
};

pub fn create_struct_binding(
    ctx: &mut Compiler,
    symbol: SymbolId,
    struct_binding: &AstStructBinding,
) {
    let ty = ctx.symbol_type(symbol);
    let reference = Value::new(ctx.alloc_hir(Hir::Reference(symbol)), ty)
        .with_reference(SymbolPath::new(symbol, vec![]));

    let mut specified_fields = HashSet::new();

    let len = struct_binding.fields().count();

    for (i, field) in struct_binding.fields().enumerate() {
        let Some(name) = field.name() else {
            continue;
        };

        if let Some(spread) = field.spread() {
            if i != len - 1 {
                ctx.diagnostic(&spread, DiagnosticKind::NonFinalSpread);
            }

            let binding_symbol = ctx.alloc_symbol(Symbol::Binding(BindingSymbol {
                name: None,
                value: reference.clone(),
                inline: true,
            }));

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

            ctx.reference(Declaration::Symbol(symbol), None);

            create_binding_for_identifier(ctx, binding_symbol, &name);

            ctx.pop_declaration();

            continue;
        }

        specified_fields.insert(name.text().to_string());

        let value = match compile_field(ctx, reference.clone(), &Field::Named(name.text())) {
            FieldResult::Value(value) => value,
            FieldResult::Unknown => {
                debug!("Unresolved field access due to unknown field");
                let type_name = ctx.type_name(reference.ty);
                ctx.diagnostic(
                    &name,
                    DiagnosticKind::UnknownField(name.text().to_string(), type_name),
                );
                ctx.builtins().unresolved.clone()
            }
            FieldResult::Error => {
                debug!("Unresolved field access due to missing field in underlying struct type");
                let type_name = ctx.type_name(reference.ty);
                ctx.diagnostic(
                    &name,
                    DiagnosticKind::MissingField(name.text().to_string(), type_name),
                );
                ctx.builtins().unresolved.clone()
            }
        };

        let field_type = value.ty;

        let binding_symbol = ctx.alloc_symbol(Symbol::Binding(BindingSymbol {
            name: None,
            value,
            inline: true,
        }));

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

        ctx.reference(Declaration::Symbol(symbol), None);

        if let Some(binding) = field.binding() {
            create_binding(ctx, binding_symbol, &binding);

            ctx.add_syntax(
                SyntaxItemKind::FieldReference(SyntaxField {
                    name: name.text().to_string(),
                    container: ty,
                    ty: field_type,
                }),
                name.text_range(),
            );
        } else {
            create_binding_for_identifier(ctx, binding_symbol, &name);
        }

        ctx.pop_declaration();
    }

    ctx.add_syntax(
        SyntaxItemKind::CompletionContext(CompletionContext::StructFields {
            ty,
            specified_fields: Some(specified_fields),
        }),
        struct_binding.syntax().text_range(),
    );
}