rsjsonnet-lang 0.5.0

A Jsonnet evaluation library
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
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157

use crate::ast;
use crate::interner::InternedStr;
use crate::span::SpanId;

#[derive(Copy, Clone, Debug)]
pub(super) enum Expr<'p> {
    Null,
    Bool(bool),
    Number(f64, SpanId),
    String(&'p str),
    Object {
        is_top: bool,
        locals: &'p [(InternedStr<'p>, &'p Expr<'p>)],
        asserts: &'p [Assert<'p>],
        fields: &'p [ObjectField<'p>],
    },
    ObjectComp {
        is_top: bool,
        locals: &'p [(InternedStr<'p>, &'p Expr<'p>)],
        field_name: &'p Expr<'p>,
        field_name_span: SpanId,
        field_plus: bool,
        field_value: &'p Expr<'p>,
        comp_spec: &'p [CompSpecPart<'p>],
    },
    Array(&'p [&'p Expr<'p>]),
    ArrayComp {
        value: &'p Expr<'p>,
        comp_spec: &'p [CompSpecPart<'p>],
    },
    Field {
        object: &'p Expr<'p>,
        field_name: InternedStr<'p>,
        expr_span: SpanId,
    },
    Index {
        object: &'p Expr<'p>,
        index: &'p Expr<'p>,
        expr_span: SpanId,
    },
    Slice {
        array: &'p Expr<'p>,
        start_index: Option<&'p Expr<'p>>,
        end_index: Option<&'p Expr<'p>>,
        step: Option<&'p Expr<'p>>,
        expr_span: SpanId,
    },
    SuperField {
        super_span: SpanId,
        field_name: InternedStr<'p>,
        expr_span: SpanId,
    },
    SuperIndex {
        super_span: SpanId,
        index: &'p Expr<'p>,
        expr_span: SpanId,
    },
    Call {
        callee: &'p Expr<'p>,
        positional_args: &'p [&'p Expr<'p>],
        named_args: &'p [(InternedStr<'p>, SpanId, &'p Expr<'p>)],
        tailstrict: bool,
        span: SpanId,
    },
    Var(InternedStr<'p>, SpanId),
    SelfObj,
    TopObj,
    Local {
        bindings: &'p [(InternedStr<'p>, &'p Expr<'p>)],
        inner: &'p Expr<'p>,
    },
    If {
        cond: &'p Expr<'p>,
        cond_span: SpanId,
        then_body: &'p Expr<'p>,
        else_body: Option<&'p Expr<'p>>,
    },
    Binary {
        op: ast::BinaryOp,
        lhs: &'p Expr<'p>,
        rhs: &'p Expr<'p>,
        span: SpanId,
    },
    Unary {
        op: ast::UnaryOp,
        rhs: &'p Expr<'p>,
        span: SpanId,
    },
    InSuper {
        lhs: &'p Expr<'p>,
        span: SpanId,
    },
    IdentityFunc,
    Func {
        params: &'p [(InternedStr<'p>, Option<&'p Expr<'p>>)],
        body: &'p Expr<'p>,
    },
    Error {
        msg: &'p Expr<'p>,
        span: SpanId,
    },
    Assert {
        assert: Assert<'p>,
        inner: &'p Expr<'p>,
    },
    Import {
        path: &'p str,
        span: SpanId,
    },
    ImportStr {
        path: &'p str,
        span: SpanId,
    },
    ImportBin {
        path: &'p str,
        span: SpanId,
    },
    OtherError {
        msg: &'p str,
    },
}

#[derive(Copy, Clone, Debug)]
pub(super) struct Assert<'p> {
    pub(super) span: SpanId,
    pub(super) cond: &'p Expr<'p>,
    pub(super) cond_span: SpanId,
    pub(super) msg: Option<&'p Expr<'p>>,
}

#[derive(Copy, Clone, Debug)]
pub(super) struct ObjectField<'p> {
    pub(super) name: FieldName<'p>,
    pub(super) name_span: SpanId,
    pub(super) plus: bool,
    pub(super) visibility: ast::Visibility,
    pub(super) value: &'p Expr<'p>,
}

#[derive(Copy, Clone, Debug)]
pub(super) enum FieldName<'p> {
    Fix(InternedStr<'p>),
    Dyn(&'p Expr<'p>),
}

#[derive(Copy, Clone, Debug)]
pub(super) enum CompSpecPart<'p> {
    For {
        var: InternedStr<'p>,
        value: &'p Expr<'p>,
        value_span: SpanId,
    },
    If {
        cond: &'p Expr<'p>,
        cond_span: SpanId,
    },
}