1use std::{2 cmp::Ordering,3 convert::Infallible,4 fmt::{Debug, Display},5 path::PathBuf,6};78use jrsonnet_gcmodule::Trace;9use jrsonnet_interner::IStr;10use jrsonnet_parser::{BinaryOpType, LocExpr, Source, SourcePath, Span, UnaryOpType};11use jrsonnet_types::ValType;12use thiserror::Error;1314use crate::{15 function::{builtin::ParamDefault, CallLocation},16 stdlib::format::FormatError,17 typed::TypeLocError,18 val::ConvertNumValueError,19 ObjValue,20};2122pub(crate) fn format_found(list: &[IStr], what: &str) -> String {23 if list.is_empty() {24 return String::new();25 }26 let mut out = String::new();27 out.push_str("\nThere ");28 if list.len() > 1 {29 out.push_str("are ");30 } else {31 out.push_str("is a ");32 }33 out.push_str(what);34 if list.len() > 1 {35 out.push('s');36 }37 out.push_str(" with similar name");38 if list.len() > 1 {39 out.push('s');40 }41 out.push_str(" present: ");42 for (i, v) in list.iter().enumerate() {43 if i != 0 {44 out.push_str(", ");45 }46 out.push_str(v as &str);47 }48 out49}5051fn format_signature(sig: &FunctionSignature) -> String {52 let mut out = String::new();53 out.push_str("\nFunction has the following signature: ");54 out.push('(');55 if sig.is_empty() {56 out.push_str("/*no arguments*/");57 } else {58 for (i, (name, default)) in sig.iter().enumerate() {59 if i != 0 {60 out.push_str(", ");61 }62 if let Some(name) = name {63 out.push_str(name);64 } else {65 out.push_str("<unnamed>");66 }67 match default {68 ParamDefault::None => {}69 ParamDefault::Exists => out.push_str(" = <default>"),70 ParamDefault::Literal(lit) => {71 out.push_str(" = ");72 out.push_str(lit);73 }74 }75 }76 }77 out.push(')');78 out79}8081const fn format_empty_str(str: &str) -> &str {82 if str.is_empty() {83 "\"\" (empty string)"84 } else {85 str86 }87}8889pub(crate) fn suggest_object_fields(v: &ObjValue, key: IStr) -> Vec<IStr> {90 let mut heap = Vec::new();91 for field in v.fields_ex(92 true,93 #[cfg(feature = "exp-preserve-order")]94 false,95 ) {96 let conf = strsim::jaro_winkler(field.as_str(), key.as_str());97 if conf < 0.8 {98 continue;99 }100 assert!(field.as_str() != key.as_str(), "looks like string pooling failure, please write any info regarding this crash to https://github.com/CertainLach/jrsonnet/issues/113, thanks!");101102 heap.push((conf, field));103 }104 heap.sort_by(|a, b| b.0.partial_cmp(&a.0).unwrap_or(Ordering::Equal));105 heap.into_iter().map(|v| v.1).collect()106}107108type FunctionSignature = Vec<(Option<IStr>, ParamDefault)>;109110111#[allow(missing_docs)]112#[derive(Error, Debug, Clone, Trace)]113#[non_exhaustive]114pub enum ErrorKind {115 #[error("intrinsic not found: {0}")]116 IntrinsicNotFound(IStr),117118 #[error("operator {0} does not operate on type {1}")]119 UnaryOperatorDoesNotOperateOnType(UnaryOpType, ValType),120 #[error("binary operation {1} {0} {2} is not implemented")]121 BinaryOperatorDoesNotOperateOnValues(BinaryOpType, ValType, ValType),122123 #[error("no top level object in this context")]124 NoTopLevelObjectFound,125 #[error("self is only usable inside objects")]126 CantUseSelfOutsideOfObject,127 #[error("no super found")]128 NoSuperFound,129130 #[error("for loop can only iterate over arrays")]131 InComprehensionCanOnlyIterateOverArray,132133 #[error("array out of bounds: {0} is not within [0,{1})")]134 ArrayBoundsError(isize, usize),135 #[error("string out of bounds: {0} is not within [0,{1})")]136 StringBoundsError(usize, usize),137138 #[error("assert failed: {}", format_empty_str(.0))]139 AssertionFailed(IStr),140141 #[error("local is not defined: {0}{}", format_found(.1, "local"))]142 VariableIsNotDefined(IStr, Vec<IStr>),143 #[error("duplicate local var: {0}")]144 DuplicateLocalVar(IStr),145146 #[error("type mismatch: expected {}, got {2} {0}", .1.iter().map(|e| format!("{e}")).collect::<Vec<_>>().join(", "))]147 TypeMismatch(&'static str, Vec<ValType>, ValType),148 #[error("no such field: {}{}", format_empty_str(.0), format_found(.1, "field"))]149 NoSuchField(IStr, Vec<IStr>),150151 #[error("only functions can be called, got {0}")]152 OnlyFunctionsCanBeCalledGot(ValType),153 #[error("parameter {0} is not defined")]154 UnknownFunctionParameter(String),155 #[error("argument {0} is already bound")]156 BindingParameterASecondTime(IStr),157 #[error("too many args, function has {0}{}", format_signature(.1))]158 TooManyArgsFunctionHas(usize, FunctionSignature),159 #[error("function argument is not passed: {}{}", .0.as_ref().map_or("<unnamed>", IStr::as_str), format_signature(.1))]160 FunctionParameterNotBoundInCall(Option<IStr>, FunctionSignature),161162 #[error("external variable is not defined: {0}")]163 UndefinedExternalVariable(IStr),164165 #[error("field name should be string, got {0}")]166 FieldMustBeStringGot(ValType),167 #[error("duplicate field name: {}", format_empty_str(.0))]168 DuplicateFieldName(IStr),169170 #[error("attempted to index array with string {}", format_empty_str(.0))]171 AttemptedIndexAnArrayWithString(IStr),172 #[error("{0} index type should be {1}, got {2}")]173 ValueIndexMustBeTypeGot(ValType, ValType, ValType),174 #[error("cant index into {0}")]175 CantIndexInto(ValType),176 #[error("{0} is not indexable")]177 ValueIsNotIndexable(ValType),178179 #[error("super can't be used standalone")]180 StandaloneSuper,181182 #[error("can't resolve {1} from {0}")]183 ImportFileNotFound(SourcePath, String),184 #[error("can't resolve absolute {0}")]185 AbsoluteImportFileNotFound(PathBuf),186 #[error("resolved file not found: {:?}", .0)]187 ResolvedFileNotFound(SourcePath),188 #[error("can't import {0}: is a directory")]189 ImportIsADirectory(SourcePath),190 #[error("imported file is not valid utf-8: {0:?}")]191 ImportBadFileUtf8(SourcePath),192 #[error("import io error: {0}")]193 ImportIo(String),194 #[error("tried to import {1} from {0}, but imports are not supported")]195 ImportNotSupported(SourcePath, String),196 #[error("tried to import {0}, but absolute imports are not supported")]197 AbsoluteImportNotSupported(PathBuf),198 #[error("can't import from virtual file")]199 CantImportFromVirtualFile,200 #[error(201 "syntax error: {}",202 203 {.error.expected.tokens().find(|t| t.starts_with("!!!")).map_or_else(|| {204 format!(205 "expected {}, got {:?}",206 .error.expected,207 .path.code().chars().nth(error.location.offset)208 .map_or_else(|| "EOF".into(), |c| c.to_string())209 )210 }, |v| v[3..].into())}211 )]212 ImportSyntaxError {213 path: Source,214 #[trace(skip)]215 error: Box<jrsonnet_parser::ParseError>,216 },217218 #[error("runtime error: {}", format_empty_str(.0))]219 RuntimeError(IStr),220 #[error("stack overflow, try to reduce recursion, or set --max-stack to bigger value")]221 StackOverflow,222 #[error("infinite recursion detected")]223 InfiniteRecursionDetected,224 #[error("tried to index by fractional value")]225 FractionalIndex,226 #[error("attempted to divide by zero")]227 DivisionByZero,228229 #[error("string manifest output is not an string")]230 StringManifestOutputIsNotAString,231 #[error("stream manifest output is not an array")]232 StreamManifestOutputIsNotAArray,233 #[error("multi manifest output is not an object")]234 MultiManifestOutputIsNotAObject,235236 #[error("cant recurse stream manifest")]237 StreamManifestOutputCannotBeRecursed,238 #[error("stream manifest output cannot consist of raw strings")]239 StreamManifestCannotNestString,240241 #[error("{}", format_empty_str(.0))]242 ImportCallbackError(String),243 #[error("invalid unicode codepoint: {0}")]244 InvalidUnicodeCodepointGot(u32),245246 #[error("convert num value: {0}")]247 ConvertNumValue(#[from] ConvertNumValueError),248249 #[error("format error: {0}")]250 Format(#[from] FormatError),251 #[error("type error: {0}")]252 TypeError(TypeLocError),253254 #[cfg(feature = "anyhow-error")]255 #[error(transparent)]256 Other(#[trace(skip)] std::rc::Rc<anyhow::Error>),257}258259#[cfg(feature = "anyhow-error")]260impl From<anyhow::Error> for Error {261 fn from(e: anyhow::Error) -> Self {262 Self::new(ErrorKind::Other(std::rc::Rc::new(e)))263 }264}265266impl From<ErrorKind> for Error {267 fn from(e: ErrorKind) -> Self {268 Self::new(e)269 }270}271272impl From<Infallible> for Error {273 fn from(_value: Infallible) -> Self {274 unreachable!()275 }276}277278279#[derive(Clone, Debug, Trace)]280pub struct StackTraceElement {281 282 283 pub location: Option<Span>,284 285 pub desc: String,286}287#[derive(Debug, Clone, Trace)]288pub struct StackTrace(pub Vec<StackTraceElement>);289290#[derive(Clone, Trace)]291pub struct Error(Box<(ErrorKind, StackTrace)>);292impl Error {293 pub fn new(e: ErrorKind) -> Self {294 Self(Box::new((e, StackTrace(vec![]))))295 }296297 pub const fn error(&self) -> &ErrorKind {298 &(self.0).0299 }300 pub fn error_mut(&mut self) -> &mut ErrorKind {301 &mut (self.0).0302 }303 pub const fn trace(&self) -> &StackTrace {304 &(self.0).1305 }306 pub fn trace_mut(&mut self) -> &mut StackTrace {307 &mut (self.0).1308 }309}310impl Display for Error {311 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {312 writeln!(f, "{}", self.0 .0)?;313 for el in &self.0 .1 .0 {314 write!(f, "\t{}", el.desc)?;315 if let Some(loc) = &el.location {316 write!(f, "at {}", loc.0 .0 .0)?;317 loc.0.map_source_locations(&[loc.1, loc.2]);318 }319 writeln!(f)?;320 }321 Ok(())322 }323}324impl Debug for Error {325 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {326 f.debug_tuple("LocError").field(&self.0).finish()327 }328}329impl std::error::Error for Error {}330331pub trait ErrorSource {332 fn to_location(self) -> Option<Span>;333}334impl ErrorSource for &LocExpr {335 fn to_location(self) -> Option<Span> {336 Some(self.span())337 }338}339impl ErrorSource for &Span {340 fn to_location(self) -> Option<Span> {341 Some(self.clone())342 }343}344impl ErrorSource for CallLocation<'_> {345 fn to_location(self) -> Option<Span> {346 self.0.cloned()347 }348}349350pub type Result<V, E = Error> = std::result::Result<V, E>;351pub trait ResultExt: Sized {352 #[must_use]353 fn with_description<O: Into<String>>(self, msg: impl FnOnce() -> O) -> Self;354 #[must_use]355 fn description(self, msg: &str) -> Self {356 self.with_description(|| msg)357 }358359 #[must_use]360 fn with_description_src<O: Into<String>>(361 self,362 src: impl ErrorSource,363 msg: impl FnOnce() -> O,364 ) -> Self;365 #[must_use]366 fn description_src(self, src: impl ErrorSource, msg: &str) -> Self {367 self.with_description_src(src, || msg)368 }369}370impl<T> ResultExt for Result<T, Error> {371 fn with_description<O: Into<String>>(mut self, msg: impl FnOnce() -> O) -> Self {372 if let Err(e) = &mut self {373 let trace = e.trace_mut();374 trace.0.push(StackTraceElement {375 location: None,376 desc: msg().into(),377 });378 }379 self380 }381382 fn with_description_src<O: Into<String>>(383 mut self,384 src: impl ErrorSource,385 msg: impl FnOnce() -> O,386 ) -> Self {387 if let Err(e) = &mut self {388 let trace = e.trace_mut();389 trace.0.push(StackTraceElement {390 location: src.to_location(),391 desc: msg().into(),392 });393 }394 self395 }396}397398#[macro_export]399macro_rules! bail {400 ($w:ident$(::$i:ident)*$(($($tt:tt)*))?) => {401 return Err($w$(::$i)*$(($($tt)*))?.into())402 };403 ($w:ident$(::$i:ident)*$({$($tt:tt)*})?) => {404 return Err($w$(::$i)*$({$($tt)*})?.into())405 };406 ($l:literal$(, $($tt:tt)*)?) => {407 return Err($crate::error::ErrorKind::RuntimeError($crate::jrsonnet_macros::format_istr!($l$(, $($tt)*)?)).into())408 };409}410411#[macro_export]412macro_rules! runtime_error {413 ($l:literal$(, $($tt:tt)*)?) => {414 $crate::error::Error::from($crate::error::ErrorKind::RuntimeError($crate::jrsonnet_macros::format_istr!($l$(, $($tt)*)?)))415 };416}