1use std::{cmp::Ordering, convert::Infallible, fmt};23use jrsonnet_gcmodule::{Acyclic, Trace};4use jrsonnet_interner::IStr;5use jrsonnet_ir::{6 BinaryOpType, ConvertNumValueError, Source, SourcePath, Span, Spanned, UnaryOpType,7};8use jrsonnet_types::ValType;9use thiserror::Error;1011use crate::{12 function::{CallLocation, FunctionSignature, ParamName},13 stdlib::format::FormatError,14 typed::TypeLocError,15 ObjValue, ResolvePathOwned,16};1718#[derive(Debug, Clone, Acyclic)]19pub struct SyntaxError {20 pub message: String,21 pub location: Span,22}23impl fmt::Display for SyntaxError {24 fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {25 write!(f, "{}", self.message)26 }27}2829pub(crate) fn format_found(list: &[IStr], what: &str) -> String {30 if list.is_empty() {31 return String::new();32 }33 let mut out = String::new();34 out.push_str("\nThere ");35 if list.len() > 1 {36 out.push_str("are ");37 } else {38 out.push_str("is a ");39 }40 out.push_str(what);41 if list.len() > 1 {42 out.push('s');43 }44 out.push_str(" with similar name");45 if list.len() > 1 {46 out.push('s');47 }48 out.push_str(" present: ");49 for (i, v) in list.iter().enumerate() {50 if i != 0 {51 out.push_str(", ");52 }53 out.push_str(v as &str);54 }55 out56}5758const fn format_empty_str(str: &str) -> &str {59 if str.is_empty() {60 "\"\" (empty string)"61 } else {62 str63 }64}6566pub(crate) fn suggest_names<'a, 'b>(67 name: &'a IStr,68 names: impl IntoIterator<Item = &'b IStr>,69) -> Vec<IStr> {70 let mut heap: Vec<(f64, IStr)> = names71 .into_iter()72 .filter_map(|def| {73 let conf = strsim::jaro_winkler(def.as_str(), name.as_str());74 if conf < 0.8 {75 return None;76 }77 debug_assert!(78 def.as_str() != name.as_str(),79 "string pooling failure: look for DOC(string-pooling) comment in jrsonnet-interner"80 );8182 Some((conf, def.clone()))83 })84 .collect();85 heap.sort_by(|a, b| b.0.partial_cmp(&a.0).unwrap_or(Ordering::Equal));86 heap.into_iter().map(|v| v.1).collect()87}8889pub(crate) fn suggest_object_fields(v: &ObjValue, key: IStr) -> Vec<IStr> {90 let fields = v.fields_ex(91 true,92 #[cfg(feature = "exp-preserve-order")]93 false,94 );95 suggest_names(&key, &fields)96}979899#[allow(missing_docs)]100#[derive(Error, Debug, Clone, Trace)]101#[non_exhaustive]102pub enum ErrorKind {103 #[error("intrinsic not found: {0}")]104 IntrinsicNotFound(IStr),105106 #[error("operator {0} does not operate on type {1}")]107 UnaryOperatorDoesNotOperateOnType(UnaryOpType, ValType),108 #[error("binary operation {1} {0} {2} is not implemented")]109 BinaryOperatorDoesNotOperateOnValues(BinaryOpType, ValType, ValType),110111 #[error("self/super/$ are only usable inside objects")]112 CantUseSelfSupOutsideOfObject,113114 #[error("static analysis errors: {}", .0.iter().map(|d| d.message.as_str()).collect::<Vec<_>>().join("; "))]115 StaticAnalysisError(Vec<crate::analyze::Diagnostic>),116 #[error("no super found")]117 NoSuperFound,118119 #[error("for loop can only iterate over arrays")]120 InComprehensionCanOnlyIterateOverArray,121122 #[error("array out of bounds: {0} is not within [0,{1})")]123 ArrayBoundsError(isize, u32),124 #[error("string out of bounds: {0} is not within [0,{1})")]125 StringBoundsError(usize, usize),126127 #[error("assert failed: {}", format_empty_str(.0))]128 AssertionFailed(IStr),129130 #[error("type mismatch: expected {expected}, got {2} {0}", expected = .1.iter().map(|e| format!("{e}")).collect::<Vec<_>>().join(", "))]131 TypeMismatch(&'static str, Vec<ValType>, ValType),132 #[error("no such field: {}{}", format_empty_str(.0), format_found(.1, "field"))]133 NoSuchField(IStr, Vec<IStr>),134135 #[error("only functions can be called, got {0}")]136 OnlyFunctionsCanBeCalledGot(ValType),137 #[error("parameter {0} is not defined")]138 UnknownFunctionParameter(IStr),139 #[error("argument {0} is already bound")]140 BindingParameterASecondTime(IStr),141 #[error("too many args, function has {0}\nFunction has the following signature: {1}")]142 TooManyArgsFunctionHas(usize, FunctionSignature),143 #[error("function argument is not passed: {0}\nFunction has the following signature: {1}")]144 FunctionParameterNotBoundInCall(ParamName, FunctionSignature),145146 #[error("external variable is not defined: {0}")]147 UndefinedExternalVariable(IStr),148149 #[error("field name should be string, got {0}")]150 FieldMustBeStringGot(ValType),151 #[error("duplicate field name: {}", format_empty_str(.0))]152 DuplicateFieldName(IStr),153154 #[error("attempted to index array with string {}", format_empty_str(.0))]155 AttemptedIndexAnArrayWithString(IStr),156 #[error("{0} index type should be {1}, got {2}")]157 ValueIndexMustBeTypeGot(ValType, ValType, ValType),158 #[error("cant index into {0}")]159 CantIndexInto(ValType),160 #[error("{0} is not indexable")]161 ValueIsNotIndexable(ValType),162163 #[error("super can't be used standalone")]164 StandaloneSuper,165166 #[error("can't resolve {1} from {0}")]167 ImportFileNotFound(SourcePath, ResolvePathOwned),168 #[error("resolved file not found: {:?}", .0)]169 ResolvedFileNotFound(SourcePath),170 #[error("can't import {0}: is a directory")]171 ImportIsADirectory(SourcePath),172 #[error("imported file is not valid utf-8: {0:?}")]173 ImportBadFileUtf8(SourcePath),174 #[error("import io error: {0}")]175 ImportIo(String),176 #[error("tried to import {1} from {0}, but imports are not supported")]177 ImportNotSupported(SourcePath, ResolvePathOwned),178 #[error("can't import from virtual file")]179 CantImportFromVirtualFile,180 #[error("syntax error: {error}")]181 ImportSyntaxError {182 path: Source,183 error: Box<SyntaxError>,184 },185186 #[error("runtime error: {}", format_empty_str(.0))]187 RuntimeError(IStr),188 #[error("stack overflow, try to reduce recursion, or set --max-stack to bigger value")]189 StackOverflow,190 #[error("infinite recursion detected")]191 InfiniteRecursionDetected,192 #[error("tried to index by fractional value")]193 FractionalIndex,194 #[error("attempted to divide by zero")]195 DivisionByZero,196197 #[error("string manifest output is not an string")]198 StringManifestOutputIsNotAString,199 #[error("stream manifest output is not an array")]200 StreamManifestOutputIsNotAArray,201 #[error("multi manifest output is not an object")]202 MultiManifestOutputIsNotAObject,203204 #[error("cant recurse stream manifest")]205 StreamManifestOutputCannotBeRecursed,206 #[error("stream manifest output cannot consist of raw strings")]207 StreamManifestCannotNestString,208209 #[error("{}", format_empty_str(.0))]210 ImportCallbackError(String),211 #[error("invalid unicode codepoint: {0}")]212 InvalidUnicodeCodepointGot(u32),213214 #[error("convert num value: {0}")]215 ConvertNumValue(#[from] ConvertNumValueError),216217 #[error("format error: {0}")]218 Format(#[from] FormatError),219 #[error("type error: {0}")]220 TypeError(TypeLocError),221222 #[cfg(feature = "anyhow-error")]223 #[error(transparent)]224 Other(#[trace(skip)] std::rc::Rc<anyhow::Error>),225}226227#[cfg(feature = "anyhow-error")]228impl From<anyhow::Error> for Error {229 fn from(e: anyhow::Error) -> Self {230 Self::new(ErrorKind::Other(std::rc::Rc::new(e)))231 }232}233234impl From<ErrorKind> for Error {235 fn from(e: ErrorKind) -> Self {236 Self::new(e)237 }238}239impl From<ConvertNumValueError> for Error {240 fn from(e: ConvertNumValueError) -> Self {241 Self::new(ErrorKind::ConvertNumValue(e))242 }243}244245impl From<Infallible> for Error {246 fn from(_value: Infallible) -> Self {247 unreachable!()248 }249}250251252#[derive(Clone, Debug, Trace)]253pub struct StackTraceElement {254 255 256 pub location: Option<Span>,257 258 pub desc: String,259}260#[derive(Debug, Clone, Trace)]261pub struct StackTrace(pub Vec<StackTraceElement>);262263#[derive(Clone, Trace)]264pub struct Error(Box<(ErrorKind, StackTrace)>);265266#[cfg(target_pointer_width = "64")]267static_assertions::assert_eq_size!(Error, usize);268269impl Error {270 pub fn new(e: ErrorKind) -> Self {271 Self(Box::new((e, StackTrace(vec![]))))272 }273274 pub const fn error(&self) -> &ErrorKind {275 &(self.0).0276 }277 pub fn error_mut(&mut self) -> &mut ErrorKind {278 &mut (self.0).0279 }280 pub const fn trace(&self) -> &StackTrace {281 &(self.0).1282 }283 pub fn trace_mut(&mut self) -> &mut StackTrace {284 &mut (self.0).1285 }286}287impl fmt::Display for Error {288 fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {289 writeln!(f, "{}", self.0 .0)?;290 for el in &self.0 .1 .0 {291 write!(f, "\t{}", el.desc)?;292 if let Some(loc) = &el.location {293 write!(f, "at {}", loc.0 .0 .0)?;294 loc.0.map_source_locations(&[loc.1, loc.2]);295 }296 writeln!(f)?;297 }298 Ok(())299 }300}301impl fmt::Debug for Error {302 fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {303 f.debug_tuple("LocError").field(&self.0).finish()304 }305}306impl std::error::Error for Error {}307308pub trait ErrorSource {309 fn to_location(self) -> Option<Span>;310}311impl<T: Acyclic> ErrorSource for &Spanned<T> {312 fn to_location(self) -> Option<Span> {313 Some(self.span.clone())314 }315}316impl ErrorSource for &Span {317 fn to_location(self) -> Option<Span> {318 Some(self.clone())319 }320}321impl ErrorSource for CallLocation<'_> {322 fn to_location(self) -> Option<Span> {323 self.0.cloned()324 }325}326327pub type Result<V, E = Error> = std::result::Result<V, E>;328pub trait ResultExt: Sized {329 #[must_use]330 fn with_description<O: Into<String>>(self, msg: impl FnOnce() -> O) -> Self;331 #[must_use]332 fn description(self, msg: &str) -> Self {333 self.with_description(|| msg)334 }335336 #[must_use]337 fn with_description_src<O: Into<String>>(338 self,339 src: impl ErrorSource,340 msg: impl FnOnce() -> O,341 ) -> Self;342 #[must_use]343 fn description_src(self, src: impl ErrorSource, msg: &str) -> Self {344 self.with_description_src(src, || msg)345 }346}347impl<T> ResultExt for Result<T, Error> {348 fn with_description<O: Into<String>>(mut self, msg: impl FnOnce() -> O) -> Self {349 if let Err(e) = &mut self {350 let trace = e.trace_mut();351 trace.0.push(StackTraceElement {352 location: None,353 desc: msg().into(),354 });355 }356 self357 }358359 fn with_description_src<O: Into<String>>(360 mut self,361 src: impl ErrorSource,362 msg: impl FnOnce() -> O,363 ) -> Self {364 if let Err(e) = &mut self {365 let trace = e.trace_mut();366 trace.0.push(StackTraceElement {367 location: src.to_location(),368 desc: msg().into(),369 });370 }371 self372 }373}374375#[macro_export]376macro_rules! bail {377 ($w:ident$(::$i:ident)*$(($($tt:tt)*))?) => {378 return Err($w$(::$i)*$(($($tt)*))?.into())379 };380 ($w:ident$(::$i:ident)*$({$($tt:tt)*})?) => {381 return Err($w$(::$i)*$({$($tt)*})?.into())382 };383 ($l:literal$(, $($tt:tt)*)?) => {384 return Err($crate::error::ErrorKind::RuntimeError($crate::jrsonnet_macros::format_istr!($l$(, $($tt)*)?)).into())385 };386}387#[macro_export]388macro_rules! error {389 ($w:ident$(::$i:ident)*$(($($tt:tt)*))?) => {390 $crate::error::Error::from($w$(::$i)*$(($($tt)*))?)391 };392 ($w:ident$(::$i:ident)*$({$($tt:tt)*})?) => {393 $crate::error::Error::from($w$(::$i)*$({$($tt)*})?)394 };395 ($l:literal$(, $($tt:tt)*)?) => {396 <$crate::error::Error as From<$crate::error::ErrorKind>>::from($crate::error::ErrorKind::RuntimeError($crate::jrsonnet_macros::format_istr!($l$(, $($tt)*)?)).into())397 };398}399400#[macro_export]401macro_rules! runtime_error {402 ($l:literal$(, $($tt:tt)*)?) => {403 $crate::error::Error::from($crate::error::ErrorKind::RuntimeError($crate::jrsonnet_macros::format_istr!($l$(, $($tt)*)?)))404 };405}