rsjsonnet_lang/program/
error.rs

1use super::{EvalStackTraceItem, ValueData};
2use crate::ast;
3use crate::lexer::LexError;
4use crate::parser::ParseError;
5use crate::span::SpanId;
6
7#[derive(Clone, Debug)]
8pub enum AnalyzeError {
9    UnknownVariable {
10        span: SpanId,
11        name: String,
12    },
13    SelfOutsideObject {
14        self_span: SpanId,
15    },
16    SuperOutsideObject {
17        super_span: SpanId,
18    },
19    DollarOutsideObject {
20        dollar_span: SpanId,
21    },
22    RepeatedLocalName {
23        original_span: SpanId,
24        repeated_span: SpanId,
25        name: String,
26    },
27    RepeatedFieldName {
28        original_span: SpanId,
29        repeated_span: SpanId,
30        name: String,
31    },
32    RepeatedParamName {
33        original_span: SpanId,
34        repeated_span: SpanId,
35        name: String,
36    },
37    PositionalArgAfterNamed {
38        arg_span: SpanId,
39    },
40    TextBlockAsImportPath {
41        span: SpanId,
42    },
43    ComputedImportPath {
44        span: SpanId,
45    },
46}
47
48#[derive(Clone, Debug, PartialEq, Eq)]
49pub struct EvalError {
50    pub stack_trace: Vec<EvalStackTraceItem>,
51    pub kind: EvalErrorKind,
52}
53
54#[derive(Clone, Debug, PartialEq, Eq)]
55pub enum EvalErrorKind {
56    StackOverflow,
57    InfiniteRecursion,
58    InvalidIndexedType {
59        span: SpanId,
60        got_type: EvalErrorValueType,
61    },
62    InvalidSlicedType {
63        span: SpanId,
64        got_type: EvalErrorValueType,
65    },
66    SliceIndexOrStepIsNotNumber {
67        span: SpanId,
68        got_type: EvalErrorValueType,
69    },
70    StringIndexIsNotNumber {
71        span: SpanId,
72        got_type: EvalErrorValueType,
73    },
74    ArrayIndexIsNotNumber {
75        span: SpanId,
76        got_type: EvalErrorValueType,
77    },
78    NumericIndexIsNotValid {
79        span: SpanId,
80        index: String,
81    },
82    NumericIndexOutOfRange {
83        span: SpanId,
84        index: usize,
85        length: usize,
86    },
87    ObjectIndexIsNotString {
88        span: SpanId,
89        got_type: EvalErrorValueType,
90    },
91    RepeatedFieldName {
92        span: SpanId,
93        name: String,
94    },
95    FieldNameIsNotString {
96        span: SpanId,
97        got_type: EvalErrorValueType,
98    },
99    UnknownObjectField {
100        span: SpanId,
101        field_name: String,
102    },
103    FieldOfNonObject {
104        span: SpanId,
105    },
106    SuperWithoutSuperObject {
107        span: SpanId,
108    },
109    ForSpecValueIsNotArray {
110        span: SpanId,
111        got_type: EvalErrorValueType,
112    },
113    CondIsNotBool {
114        span: SpanId,
115        got_type: EvalErrorValueType,
116    },
117    CalleeIsNotFunction {
118        span: Option<SpanId>,
119        got_type: EvalErrorValueType,
120    },
121    TooManyCallArgs {
122        span: Option<SpanId>,
123        num_params: usize,
124    },
125    UnknownCallParam {
126        span: Option<SpanId>,
127        param_name: String,
128    },
129    RepeatedCallParam {
130        span: Option<SpanId>,
131        param_name: String,
132    },
133    CallParamNotBound {
134        span: Option<SpanId>,
135        param_name: String,
136    },
137    NativeCallFailed,
138    InvalidUnaryOpType {
139        span: SpanId,
140        op: ast::UnaryOp,
141        rhs_type: EvalErrorValueType,
142    },
143    InvalidBinaryOpTypes {
144        span: Option<SpanId>,
145        op: ast::BinaryOp,
146        lhs_type: EvalErrorValueType,
147        rhs_type: EvalErrorValueType,
148    },
149    NumberOverflow {
150        span: Option<SpanId>,
151    },
152    NumberNan {
153        span: Option<SpanId>,
154    },
155    DivByZero {
156        span: Option<SpanId>,
157    },
158    ShiftByNegative {
159        span: Option<SpanId>,
160    },
161    InvalidStdFuncArgType {
162        func_name: String,
163        arg_index: usize,
164        expected_types: Vec<EvalErrorValueType>,
165        got_type: EvalErrorValueType,
166    },
167    AssertFailed {
168        span: SpanId,
169        message: Option<String>,
170    },
171    AssertEqualFailed {
172        lhs: String,
173        rhs: String,
174    },
175    ExplicitError {
176        span: SpanId,
177        message: String,
178    },
179    ImportFailed {
180        span: SpanId,
181        path: String,
182    },
183    UnknownExtVar {
184        name: String,
185    },
186    ManifestFunction,
187    CompareNullInequality,
188    CompareBooleanInequality,
189    CompareObjectInequality,
190    CompareFunctions,
191    CompareDifferentTypesInequality {
192        lhs_type: EvalErrorValueType,
193        rhs_type: EvalErrorValueType,
194    },
195    PrimitiveEqualsNonPrimitive {
196        got_type: EvalErrorValueType,
197    },
198    Other {
199        span: Option<SpanId>,
200        message: String,
201    },
202}
203
204#[derive(Copy, Clone, Debug, PartialEq, Eq)]
205pub enum EvalErrorValueType {
206    Null,
207    Bool,
208    Number,
209    String,
210    Array,
211    Object,
212    Function,
213}
214
215impl EvalErrorValueType {
216    pub(super) fn from_value(value: &ValueData<'_>) -> Self {
217        match value {
218            ValueData::Null => Self::Null,
219            ValueData::Bool(_) => Self::Bool,
220            ValueData::Number(_) => Self::Number,
221            ValueData::String(_) => Self::String,
222            ValueData::Array(_) => Self::Array,
223            ValueData::Object(_) => Self::Object,
224            ValueData::Function(_) => Self::Function,
225        }
226    }
227
228    pub(super) fn to_str(self) -> &'static str {
229        match self {
230            Self::Null => "null",
231            Self::Bool => "boolean",
232            Self::Number => "number",
233            Self::String => "string",
234            Self::Array => "array",
235            Self::Object => "object",
236            Self::Function => "function",
237        }
238    }
239}
240
241#[derive(Debug)]
242pub enum LoadError {
243    Lex(LexError),
244    Parse(ParseError),
245    Analyze(AnalyzeError),
246}
247
248impl From<LexError> for LoadError {
249    #[inline]
250    fn from(err: LexError) -> Self {
251        Self::Lex(err)
252    }
253}
254
255impl From<ParseError> for LoadError {
256    #[inline]
257    fn from(err: ParseError) -> Self {
258        Self::Parse(err)
259    }
260}
261
262impl From<AnalyzeError> for LoadError {
263    #[inline]
264    fn from(err: AnalyzeError) -> Self {
265        Self::Analyze(err)
266    }
267}
rsjsonnet_lang/program/error.rs

rsjsonnet_lang/program/
error.rs
