pax-language 0.39.1

Pax language parser
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

use std::collections::HashMap;

use pax_runtime_api::{LocalProperty, PaxValue, Variable};

use super::{
    PaxAccessor, PaxExpression, PaxInfix, PaxNullCoalesce, PaxPostfix, PaxPrefix, PaxPrimary,
    PaxTernary,
};

/// Trait for resolving identifiers to values
/// This is implemented by RuntimePropertyStackFrame
pub trait IdentifierResolver {
    fn resolve(&self, name: String) -> Result<Variable, String>;
}

/// Walk an expression tree and report the symbols that should dirty-watch it.
pub trait DependencyCollector {
    fn collect_dependencies(&self) -> Vec<String>;
}

impl DependencyCollector for PaxExpression {
    fn collect_dependencies(&self) -> Vec<String> {
        match self {
            PaxExpression::Primary(p) => p.collect_dependencies(),
            PaxExpression::Prefix(p) => p.collect_dependencies(),
            PaxExpression::Infix(p) => p.collect_dependencies(),
            PaxExpression::Postfix(p) => p.collect_dependencies(),
            PaxExpression::Ternary(p) => p.collect_dependencies(),
            PaxExpression::NullCoalesce(p) => p.collect_dependencies(),
        }
    }
}

impl DependencyCollector for PaxPrimary {
    fn collect_dependencies(&self) -> Vec<String> {
        let mut ret = match self {
            PaxPrimary::Literal(_) => vec![],
            PaxPrimary::Grouped(expr, _) => expr.collect_dependencies(),
            PaxPrimary::Identifier(i, accessors) => {
                let mut deps = vec![i.name.clone()];
                for accessor in accessors {
                    if let PaxAccessor::List(index) = accessor {
                        deps.extend(index.collect_dependencies());
                    }
                }
                deps
            }
            PaxPrimary::Object(o) => o
                .iter()
                .flat_map(|(_, v)| v.collect_dependencies())
                .collect(),
            PaxPrimary::FunctionOrEnum(_, _, args) => {
                args.iter().flat_map(|a| a.collect_dependencies()).collect()
            }
            PaxPrimary::Range(start, end) => {
                let mut deps = start.collect_dependencies();
                deps.extend(end.collect_dependencies());
                deps
            }
            PaxPrimary::Tuple(t) => t.iter().flat_map(|e| e.collect_dependencies()).collect(),
            PaxPrimary::List(l) => l.iter().flat_map(|e| e.collect_dependencies()).collect(),
        };
        // Keep first occurrence order: these dependencies are serialized into
        // generated manifests and baked programs, whose identity must be stable.
        let mut seen = std::collections::HashSet::new();
        ret.retain(|dependency| seen.insert(dependency.clone()));
        ret
    }
}

impl DependencyCollector for PaxPrefix {
    fn collect_dependencies(&self) -> Vec<String> {
        self.rhs.collect_dependencies()
    }
}

impl DependencyCollector for PaxInfix {
    fn collect_dependencies(&self) -> Vec<String> {
        let mut deps = self.lhs.collect_dependencies();
        deps.extend(self.rhs.collect_dependencies());
        deps
    }
}

impl DependencyCollector for PaxPostfix {
    fn collect_dependencies(&self) -> Vec<String> {
        self.lhs.collect_dependencies()
    }
}

impl DependencyCollector for PaxTernary {
    fn collect_dependencies(&self) -> Vec<String> {
        let mut deps = self.condition.collect_dependencies();
        deps.extend(self.then_branch.collect_dependencies());
        deps.extend(self.else_branch.collect_dependencies());
        deps
    }
}

impl DependencyCollector for PaxNullCoalesce {
    fn collect_dependencies(&self) -> Vec<String> {
        let mut deps = self.lhs.collect_dependencies();
        deps.extend(self.rhs.collect_dependencies());
        deps
    }
}

impl IdentifierResolver for HashMap<String, PaxValue> {
    fn resolve(&self, name: String) -> Result<Variable, String> {
        self.get(&name)
            // A value map supplies local snapshots, not shared application state.
            // Resolving it must not require a PropertyGraph attachment.
            .map(|v| Variable::new_from_typed_property(LocalProperty::new(v.clone())))
            .ok_or(format!("Identifier not found: {}", name))
    }
}