yog-script-analyze 0.2.2

Yog Script (.ys, .yns) analyzed: its lexer, parser and syntax tree, names resolved, the class index model — what the build and the editors read a source with.
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

//! Indexing (`x[i]`): a call of the indexer the indexed type declares or
//! inherits (`this[i32 i]`), its parameters matched as a method's are.

use yog_ids::script_problem;

use super::Checker;
use super::members::Callee;
use super::model::Type;
use crate::ast::{Arg, Expr};
use crate::source::token::Span;

impl Checker<'_, '_, '_> {
    /// `on[index]`: what the indexer gives.
    pub(super) fn indexed(&mut self, on: Type, index: &Expr, at: Span) -> Type {
        match on {
            Type::List(item) => {
                self.expr(index);
                return *item;
            }
            Type::Map(_, value) => {
                self.expr(index);
                return *value;
            }
            _ => {}
        }
        let Some(callee) = self.indexer(&on) else {
            self.expr(index);
            return Type::Unknown;
        };
        let given = vec![self.expr(index)];
        let args = [Arg {
            name: None,
            pass: None,
            value: index.clone(),
        }];
        self.called(callee, &given, &args, at)
    }

    /// `on[…] = v` where `on`'s indexers are all `get`-only: said so.
    pub(super) fn index_written(&mut self, on: &Expr, at: Span) {
        let Some(Type::Own(type_name, _)) = self.types.of(on).map(Type::non_null).cloned() else {
            return;
        };
        let indexers: Vec<bool> = self
            .own
            .lineage(&type_name)
            .iter()
            .filter_map(|of| self.own.types.get(of))
            .flat_map(|t| t.indexers.iter().map(|i| i.settable))
            .collect();
        if !indexers.is_empty() && !indexers.contains(&true) {
            self.report.error(
                script_problem::ASSIGN_TO_CONSTANT,
                at,
                format!(
                    "`{type_name}`'s indexer has no `set`: its items are read here, never written"
                ),
            );
        }
    }

    /// The indexers of `on`'s type and of what it inherits, as a callee.
    fn indexer(&self, on: &Type) -> Option<Callee> {
        let Type::Own(type_name, args) = on.non_null() else {
            return None;
        };
        let getters: Vec<_> = self
            .own
            .lineage(type_name)
            .iter()
            .filter_map(|of| self.own.types.get(of))
            .flat_map(|t| t.indexers.iter().map(|i| i.get.clone()))
            .collect();
        (!getters.is_empty()).then(|| Callee::Own(getters, self.bound_of(type_name, args)))
    }
}