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    NumberNotBitwiseSafe {
150        span: Option<SpanId>,
151    },
152    NumberOverflow {
153        span: Option<SpanId>,
154    },
155    NumberNan {
156        span: Option<SpanId>,
157    },
158    DivByZero {
159        span: Option<SpanId>,
160    },
161    ShiftByNegative {
162        span: Option<SpanId>,
163    },
164    InvalidStdFuncArgType {
165        func_name: String,
166        arg_index: usize,
167        expected_types: Vec<EvalErrorValueType>,
168        got_type: EvalErrorValueType,
169    },
170    AssertFailed {
171        span: SpanId,
172        message: Option<String>,
173    },
174    AssertEqualFailed {
175        lhs: String,
176        rhs: String,
177    },
178    ExplicitError {
179        span: SpanId,
180        message: String,
181    },
182    ImportFailed {
183        span: SpanId,
184        path: String,
185    },
186    UnknownExtVar {
187        name: String,
188    },
189    ManifestFunction,
190    CompareNullInequality,
191    CompareBooleanInequality,
192    CompareObjectInequality,
193    CompareFunctions,
194    CompareDifferentTypesInequality {
195        lhs_type: EvalErrorValueType,
196        rhs_type: EvalErrorValueType,
197    },
198    PrimitiveEqualsNonPrimitive {
199        got_type: EvalErrorValueType,
200    },
201    Other {
202        span: Option<SpanId>,
203        message: String,
204    },
205}
206
207#[derive(Copy, Clone, Debug, PartialEq, Eq)]
208pub enum EvalErrorValueType {
209    Null,
210    Bool,
211    Number,
212    String,
213    Array,
214    Object,
215    Function,
216}
217
218impl EvalErrorValueType {
219    pub(super) fn from_value(value: &ValueData<'_>) -> Self {
220        match value {
221            ValueData::Null => Self::Null,
222            ValueData::Bool(_) => Self::Bool,
223            ValueData::Number(_) => Self::Number,
224            ValueData::String(_) => Self::String,
225            ValueData::Array(_) => Self::Array,
226            ValueData::Object(_) => Self::Object,
227            ValueData::Function(_) => Self::Function,
228        }
229    }
230
231    pub(super) fn to_str(self) -> &'static str {
232        match self {
233            Self::Null => "null",
234            Self::Bool => "boolean",
235            Self::Number => "number",
236            Self::String => "string",
237            Self::Array => "array",
238            Self::Object => "object",
239            Self::Function => "function",
240        }
241    }
242}
243
244#[derive(Debug)]
245pub enum LoadError {
246    Lex(LexError),
247    Parse(ParseError),
248    Analyze(AnalyzeError),
249}
250
251impl From<LexError> for LoadError {
252    #[inline]
253    fn from(err: LexError) -> Self {
254        Self::Lex(err)
255    }
256}
257
258impl From<ParseError> for LoadError {
259    #[inline]
260    fn from(err: ParseError) -> Self {
261        Self::Parse(err)
262    }
263}
264
265impl From<AnalyzeError> for LoadError {
266    #[inline]
267    fn from(err: AnalyzeError) -> Self {
268        Self::Analyze(err)
269    }
270}
rsjsonnet_lang/program/error.rs

rsjsonnet_lang/program/
error.rs
