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 is ");28 out.push_str(what);29 if list.len() > 1 {30 out.push('s');31 }32 out.push_str(" with similar name");33 if list.len() > 1 {34 out.push('s');35 }36 out.push_str(" present: ");37 for (i, v) in list.iter().enumerate() {38 if i != 0 {39 out.push_str(", ");40 }41 out.push_str(v as &str);42 }43 out44}4546fn format_signature(sig: &FunctionSignature) -> String {47 let mut out = String::new();48 out.push_str("\nFunction has the following signature: ");49 out.push('(');50 if sig.is_empty() {51 out.push_str("/*no arguments*/");52 } else {53 for (i, (name, default)) in sig.iter().enumerate() {54 if i != 0 {55 out.push_str(", ");56 }57 if let Some(name) = name {58 out.push_str(name);59 } else {60 out.push_str("<unnamed>");61 }62 match default {63 ParamDefault::None => {}64 ParamDefault::Exists => out.push_str(" = <default>"),65 ParamDefault::Literal(lit) => {66 out.push_str(" = ");67 out.push_str(lit);68 }69 }70 }71 }72 out.push(')');73 out74}7576const fn format_empty_str(str: &str) -> &str {77 if str.is_empty() {78 "\"\" (empty string)"79 } else {80 str81 }82}8384pub(crate) fn suggest_object_fields(v: &ObjValue, key: IStr) -> Vec<IStr> {85 let mut heap = Vec::new();86 for field in v.fields_ex(87 true,88 #[cfg(feature = "exp-preserve-order")]89 false,90 ) {91 let conf = strsim::jaro_winkler(field.as_str(), key.as_str());92 if conf < 0.8 {93 continue;94 }95 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!");9697 heap.push((conf, field));98 }99 heap.sort_by(|a, b| b.0.partial_cmp(&a.0).unwrap_or(Ordering::Equal));100 heap.into_iter().map(|v| v.1).collect()101}102103type FunctionSignature = Vec<(Option<IStr>, ParamDefault)>;104105106#[allow(missing_docs)]107#[derive(Error, Debug, Clone, Trace)]108#[non_exhaustive]109pub enum ErrorKind {110 #[error("intrinsic not found: {0}")]111 IntrinsicNotFound(IStr),112113 #[error("operator {0} does not operate on type {1}")]114 UnaryOperatorDoesNotOperateOnType(UnaryOpType, ValType),115 #[error("binary operation {1} {0} {2} is not implemented")]116 BinaryOperatorDoesNotOperateOnValues(BinaryOpType, ValType, ValType),117118 #[error("no top level object in this context")]119 NoTopLevelObjectFound,120 #[error("self is only usable inside objects")]121 CantUseSelfOutsideOfObject,122 #[error("no super found")]123 NoSuperFound,124125 #[error("for loop can only iterate over arrays")]126 InComprehensionCanOnlyIterateOverArray,127128 #[error("array out of bounds: {0} is not within [0,{1})")]129 ArrayBoundsError(isize, usize),130 #[error("string out of bounds: {0} is not within [0,{1})")]131 StringBoundsError(usize, usize),132133 #[error("assert failed: {}", format_empty_str(.0))]134 AssertionFailed(IStr),135136 #[error("variable is not defined: {0}{}", format_found(.1, "variable"))]137 VariableIsNotDefined(IStr, Vec<IStr>),138 #[error("duplicate local var: {0}")]139 DuplicateLocalVar(IStr),140141 #[error("type mismatch: expected {}, got {2} {0}", .1.iter().map(|e| format!("{e}")).collect::<Vec<_>>().join(", "))]142 TypeMismatch(&'static str, Vec<ValType>, ValType),143 #[error("no such field: {}{}", format_empty_str(.0), format_found(.1, "field"))]144 NoSuchField(IStr, Vec<IStr>),145146 #[error("only functions can be called, got {0}")]147 OnlyFunctionsCanBeCalledGot(ValType),148 #[error("parameter {0} is not defined")]149 UnknownFunctionParameter(String),150 #[error("argument {0} is already bound")]151 BindingParameterASecondTime(IStr),152 #[error("too many args, function has {0}{}", format_signature(.1))]153 TooManyArgsFunctionHas(usize, FunctionSignature),154 #[error("function argument is not passed: {}{}", .0.as_ref().map_or("<unnamed>", IStr::as_str), format_signature(.1))]155 FunctionParameterNotBoundInCall(Option<IStr>, FunctionSignature),156157 #[error("external variable is not defined: {0}")]158 UndefinedExternalVariable(IStr),159160 #[error("field name should be string, got {0}")]161 FieldMustBeStringGot(ValType),162 #[error("duplicate field name: {}", format_empty_str(.0))]163 DuplicateFieldName(IStr),164165 #[error("attempted to index array with string {}", format_empty_str(.0))]166 AttemptedIndexAnArrayWithString(IStr),167 #[error("{0} index type should be {1}, got {2}")]168 ValueIndexMustBeTypeGot(ValType, ValType, ValType),169 #[error("cant index into {0}")]170 CantIndexInto(ValType),171 #[error("{0} is not indexable")]172 ValueIsNotIndexable(ValType),173174 #[error("super can't be used standalone")]175 StandaloneSuper,176177 #[error("can't resolve {1} from {0}")]178 ImportFileNotFound(SourcePath, String),179 #[error("can't resolve absolute {0}")]180 AbsoluteImportFileNotFound(PathBuf),181 #[error("resolved file not found: {:?}", .0)]182 ResolvedFileNotFound(SourcePath),183 #[error("can't import {0}: is a directory")]184 ImportIsADirectory(SourcePath),185 #[error("imported file is not valid utf-8: {0:?}")]186 ImportBadFileUtf8(SourcePath),187 #[error("import io error: {0}")]188 ImportIo(String),189 #[error("tried to import {1} from {0}, but imports are not supported")]190 ImportNotSupported(SourcePath, String),191 #[error("tried to import {0}, but absolute imports are not supported")]192 AbsoluteImportNotSupported(PathBuf),193 #[error("can't import from virtual file")]194 CantImportFromVirtualFile,195 #[error(196 "syntax error: {}",197 198 {.error.expected.tokens().find(|t| t.starts_with("!!!")).map_or_else(|| {199 format!(200 "expected {}, got {:?}",201 .error.expected,202 .path.code().chars().nth(error.location.offset)203 .map_or_else(|| "EOF".into(), |c| c.to_string())204 )205 }, |v| v[3..].into())}206 )]207 ImportSyntaxError {208 path: Source,209 #[trace(skip)]210 error: Box<jrsonnet_parser::ParseError>,211 },212213 #[error("runtime error: {}", format_empty_str(.0))]214 RuntimeError(IStr),215 #[error("stack overflow, try to reduce recursion, or set --max-stack to bigger value")]216 StackOverflow,217 #[error("infinite recursion detected")]218 InfiniteRecursionDetected,219 #[error("tried to index by fractional value")]220 FractionalIndex,221 #[error("attempted to divide by zero")]222 DivisionByZero,223224 #[error("string manifest output is not an string")]225 StringManifestOutputIsNotAString,226 #[error("stream manifest output is not an array")]227 StreamManifestOutputIsNotAArray,228 #[error("multi manifest output is not an object")]229 MultiManifestOutputIsNotAObject,230231 #[error("cant recurse stream manifest")]232 StreamManifestOutputCannotBeRecursed,233 #[error("stream manifest output cannot consist of raw strings")]234 StreamManifestCannotNestString,235236 #[error("{}", format_empty_str(.0))]237 ImportCallbackError(String),238 #[error("invalid unicode codepoint: {0}")]239 InvalidUnicodeCodepointGot(u32),240241 #[error("convert num value: {0}")]242 ConvertNumValue(#[from] ConvertNumValueError),243244 #[error("format error: {0}")]245 Format(#[from] FormatError),246 #[error("type error: {0}")]247 TypeError(TypeLocError),248249 #[cfg(feature = "anyhow-error")]250 #[error(transparent)]251 Other(#[trace(skip)] std::rc::Rc<anyhow::Error>),252}253254#[cfg(feature = "anyhow-error")]255impl From<anyhow::Error> for Error {256 fn from(e: anyhow::Error) -> Self {257 Self::new(ErrorKind::Other(std::rc::Rc::new(e)))258 }259}260261impl From<ErrorKind> for Error {262 fn from(e: ErrorKind) -> Self {263 Self::new(e)264 }265}266267impl From<Infallible> for Error {268 fn from(_value: Infallible) -> Self {269 unreachable!()270 }271}272273274#[derive(Clone, Debug, Trace)]275pub struct StackTraceElement {276 277 278 pub location: Option<Span>,279 280 pub desc: String,281}282#[derive(Debug, Clone, Trace)]283pub struct StackTrace(pub Vec<StackTraceElement>);284285#[derive(Clone, Trace)]286pub struct Error(Box<(ErrorKind, StackTrace)>);287impl Error {288 pub fn new(e: ErrorKind) -> Self {289 Self(Box::new((e, StackTrace(vec![]))))290 }291292 pub const fn error(&self) -> &ErrorKind {293 &(self.0).0294 }295 pub fn error_mut(&mut self) -> &mut ErrorKind {296 &mut (self.0).0297 }298 pub const fn trace(&self) -> &StackTrace {299 &(self.0).1300 }301 pub fn trace_mut(&mut self) -> &mut StackTrace {302 &mut (self.0).1303 }304}305impl Display for Error {306 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {307 writeln!(f, "{}", self.0 .0)?;308 for el in &self.0 .1 .0 {309 write!(f, "\t{}", el.desc)?;310 if let Some(loc) = &el.location {311 write!(f, "at {}", loc.0 .0 .0)?;312 loc.0.map_source_locations(&[loc.1, loc.2]);313 }314 writeln!(f)?;315 }316 Ok(())317 }318}319impl Debug for Error {320 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {321 f.debug_tuple("LocError").field(&self.0).finish()322 }323}324impl std::error::Error for Error {}325326pub trait ErrorSource {327 fn to_location(self) -> Option<Span>;328}329impl ErrorSource for &LocExpr {330 fn to_location(self) -> Option<Span> {331 Some(self.span())332 }333}334impl ErrorSource for &Span {335 fn to_location(self) -> Option<Span> {336 Some(self.clone())337 }338}339impl ErrorSource for CallLocation<'_> {340 fn to_location(self) -> Option<Span> {341 self.0.cloned()342 }343}344345pub type Result<V, E = Error> = std::result::Result<V, E>;346pub trait ResultExt: Sized {347 #[must_use]348 fn with_description<O: Into<String>>(self, msg: impl FnOnce() -> O) -> Self;349 #[must_use]350 fn description(self, msg: &str) -> Self {351 self.with_description(|| msg)352 }353354 #[must_use]355 fn with_description_src<O: Into<String>>(356 self,357 src: impl ErrorSource,358 msg: impl FnOnce() -> O,359 ) -> Self;360 #[must_use]361 fn description_src(self, src: impl ErrorSource, msg: &str) -> Self {362 self.with_description_src(src, || msg)363 }364}365impl<T> ResultExt for Result<T, Error> {366 fn with_description<O: Into<String>>(mut self, msg: impl FnOnce() -> O) -> Self {367 if let Err(e) = &mut self {368 let trace = e.trace_mut();369 trace.0.push(StackTraceElement {370 location: None,371 desc: msg().into(),372 });373 }374 self375 }376377 fn with_description_src<O: Into<String>>(378 mut self,379 src: impl ErrorSource,380 msg: impl FnOnce() -> O,381 ) -> Self {382 if let Err(e) = &mut self {383 let trace = e.trace_mut();384 trace.0.push(StackTraceElement {385 location: src.to_location(),386 desc: msg().into(),387 });388 }389 self390 }391}392393#[macro_export]394macro_rules! bail {395 ($w:ident$(::$i:ident)*$(($($tt:tt)*))?) => {396 return Err($w$(::$i)*$(($($tt)*))?.into())397 };398 ($w:ident$(::$i:ident)*$({$($tt:tt)*})?) => {399 return Err($w$(::$i)*$({$($tt)*})?.into())400 };401 ($l:literal$(, $($tt:tt)*)?) => {402 return Err($crate::error::ErrorKind::RuntimeError($crate::jrsonnet_macros::format_istr!($l$(, $($tt)*)?)).into())403 };404}405406#[macro_export]407macro_rules! runtime_error {408 ($l:literal$(, $($tt:tt)*)?) => {409 $crate::error::Error::from($crate::error::ErrorKind::RuntimeError($crate::jrsonnet_macros::format_istr!($l$(, $($tt)*)?)))410 };411}