knave-expand 0.14.22

The reading, scoping and expansion stages of knave
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

use std::rc::Rc;

use super::Expander;
use super::problems::ExpandProblems;
use crate::core::{
    Binder, BindingInfo, BindingKind, Block, BodyItem, Expr, ExprKind, FieldLabel, FieldSpelling,
    Keyword, Lambda, Leaf, StructExpr,
};
use crate::diagnostic::Diagnostic;
use crate::reader::Form;
use crate::source::Span;

impl Expander<'_> {
    const FIELD_READER_PARAMETER: &'static str = "value";

    pub(super) fn lower_field_keyword_call(
        &mut self,
        form: &Form,
        field_name: &str,
    ) -> Result<Expr, Diagnostic> {
        let items = form.as_list().unwrap_or_default();
        let [keyword, value] = items else {
            return Err(Self::field_keyword_arity(form, items));
        };
        let value = self.lower_recovered(value)?;
        let label = Self::keyword_label(field_name, keyword.span());
        Ok(Self::field_read(value, label, form.span()))
    }

    pub(super) fn lower_field_reader(&mut self, field_name: &str, span: Span) -> ExprKind {
        let parameter = self.tables.bindings.add(BindingInfo::new(
            Self::FIELD_READER_PARAMETER.into(),
            BindingKind::Local,
            Some(span),
        ));
        let value = Expr::new(ExprKind::Leaf(Leaf::Var(parameter)), span);
        let read = Self::field_read(value, Self::keyword_label(field_name, span), span);
        ExprKind::Fn(Rc::new(Lambda::new(
            vec![Binder {
                binding: parameter,
                annotation: None,
                span,
            }],
            Block {
                items: vec![BodyItem::Expr(read)],
            },
        )))
    }

    pub(super) fn reject_keyword_binder(name: &str, span: Span) -> Result<(), Diagnostic> {
        match Keyword::field_name(name) {
            Some(_) => Err(ExpandProblems::keyword_binder(span)),
            None => Ok(()),
        }
    }

    pub(super) fn written_field_keyword(form: &Form) -> Option<&str> {
        Keyword::field_name(form.as_symbol()?.name())
    }

    fn field_keyword_arity(form: &Form, items: &[Form]) -> Diagnostic {
        let keyword = items[0].to_string();
        match items.get(2) {
            Some(extra) => ExpandProblems::extra_field_keyword_value(&keyword, extra.span()),
            None => ExpandProblems::missing_field_keyword_value(&keyword, form.span()),
        }
    }

    pub(super) fn keyword_label(field_name: &str, span: Span) -> FieldLabel {
        FieldLabel {
            name: field_name.into(),
            span,
            spelling: FieldSpelling::Keyword,
        }
    }

    fn field_read(value: Expr, label: FieldLabel, span: Span) -> Expr {
        Expr::new(
            ExprKind::Struct(StructExpr::Field(Box::new(value), label)),
            span,
        )
    }
}