git.delta.rocks / jrsonnet / refs/commits / 9f8d4fc520b3

--- a/Cargo.toml
+++ b/Cargo.toml
@@ -1,9 +1,5 @@
 [workspace]
-members = [
-	"crates/*",
-	"bindings/jsonnet",
-	"cmds/jrsonnet",
-]
+members = ["crates/*", "bindings/jsonnet", "cmds/jrsonnet"]
 
 [profile.test]
 opt-level = 1
@@ -14,3 +10,4 @@
 codegen-units = 1
 debug = 0
 panic = "abort"
+strip = true

--- a/bindings/jsonnet/src/import.rs
+++ b/bindings/jsonnet/src/import.rs
@@ -32,9 +32,9 @@
 	out: RefCell<HashMap<PathBuf, Vec<u8>>>,
 }
 impl ImportResolver for CallbackImportResolver {
-	fn resolve_file(&self, from: &Path, path: &Path) -> Result<PathBuf> {
+	fn resolve_file(&self, from: &Path, path: &str) -> Result<PathBuf> {
 		let base = CString::new(from.to_str().unwrap()).unwrap().into_raw();
-		let rel = CString::new(path.to_str().unwrap()).unwrap().into_raw();
+		let rel = CString::new(path).unwrap().into_raw();
 		let found_here: *mut c_char = null_mut();
 		let mut success: i32 = 0;
 		let result_ptr = unsafe {
@@ -108,17 +108,17 @@
 	}
 }
 impl ImportResolver for NativeImportResolver {
-	fn resolve_file(&self, from: &Path, path: &Path) -> Result<PathBuf> {
+	fn resolve_file(&self, from: &Path, path: &str) -> Result<PathBuf> {
 		let mut new_path = from.to_owned();
 		new_path.push(path);
 		if new_path.exists() {
-			Ok(new_path.into())
+			Ok(new_path)
 		} else {
 			for library_path in self.library_paths.borrow().iter() {
 				let mut cloned = library_path.clone();
 				cloned.push(path);
 				if cloned.exists() {
-					return Ok(cloned.into());
+					return Ok(cloned);
 				}
 			}
 			throw!(ImportFileNotFound(from.to_owned(), path.to_owned()))

--- a/bindings/jsonnet/src/vars_tlas.rs
+++ b/bindings/jsonnet/src/vars_tlas.rs
@@ -20,11 +20,8 @@
 pub unsafe extern "C" fn jsonnet_ext_code(vm: &State, name: *const c_char, value: *const c_char) {
 	let name = CStr::from_ptr(name);
 	let value = CStr::from_ptr(value);
-	vm.add_ext_code(
-		name.to_str().unwrap().into(),
-		value.to_str().unwrap().into(),
-	)
-	.unwrap()
+	vm.add_ext_code(name.to_str().unwrap(), value.to_str().unwrap().into())
+		.unwrap()
 }
 /// # Safety
 #[no_mangle]
@@ -41,9 +38,6 @@
 pub unsafe extern "C" fn jsonnet_tla_code(vm: &State, name: *const c_char, value: *const c_char) {
 	let name = CStr::from_ptr(name);
 	let value = CStr::from_ptr(value);
-	vm.add_tla_code(
-		name.to_str().unwrap().into(),
-		value.to_str().unwrap().into(),
-	)
-	.unwrap()
+	vm.add_tla_code(name.to_str().unwrap().into(), value.to_str().unwrap())
+		.unwrap()
 }

--- a/crates/jrsonnet-evaluator/Cargo.toml
+++ b/crates/jrsonnet-evaluator/Cargo.toml
@@ -7,13 +7,16 @@
 edition = "2021"
 
 [features]
-default = ["serialized-stdlib", "explaining-traces"]
+default = ["serialized-stdlib", "explaining-traces", "friendly-errors"]
 # Serializes standard library AST instead of parsing them every run
 serialized-stdlib = ["bincode", "jrsonnet-parser/serde"]
 # Rustc-like trace visualization
 explaining-traces = ["annotate-snippets"]
 # Allows library authors to throw custom errors
 anyhow-error = ["anyhow"]
+# Provides helpful explaintations to errors, at cost of adding
+# more dependencies and slowing down error path
+friendly-errors = ["strsim"]
 
 # Allows to preserve field order in objects
 exp-preserve-order = []
@@ -42,20 +45,13 @@
 serde_json = "1.0"
 serde_yaml = { git = "https://github.com/CertainLach/serde-yaml", branch = "feature/old-octals-quirk" }
 
-[dependencies.anyhow]
-version = "1.0"
-optional = true
-
+anyhow = { version = "1.0", optional = true }
+# Friendly errors
+strsim = { version = "0.10.0", optional = true }
 # Serialized stdlib
-[dependencies.bincode]
-version = "1.3"
-optional = true
-
+bincode = { version = "1.3", optional = true }
 # Explaining traces
-[dependencies.annotate-snippets]
-version = "0.9.1"
-features = ["color"]
-optional = true
+annotate-snippets = { version = "0.9.1", features = ["color"], optional = true }
 
 [build-dependencies]
 jrsonnet-stdlib = { path = "../jrsonnet-stdlib", version = "0.4.2" }

--- a/crates/jrsonnet-evaluator/src/ctx.rs
+++ b/crates/jrsonnet-evaluator/src/ctx.rs
@@ -49,13 +49,40 @@
 		}))
 	}
 
+	#[cfg(not(feature = "friendly-errors"))]
 	pub fn binding(&self, name: IStr) -> Result<Thunk<Val>> {
 		Ok(self
 			.0
 			.bindings
 			.get(&name)
 			.cloned()
-			.ok_or(VariableIsNotDefined(name))?)
+			.ok_or(VariableIsNotDefined(name, vec![]))?)
+	}
+
+	#[cfg(feature = "friendly-errors")]
+	pub fn binding(&self, name: IStr) -> Result<Thunk<Val>> {
+		use std::cmp::Ordering;
+
+		use crate::throw;
+
+		if let Some(val) = self.0.bindings.get(&name).cloned() {
+			return Ok(val);
+		}
+
+		let mut heap = Vec::new();
+		self.0.bindings.clone().iter_keys(|k| {
+			let conf = strsim::jaro_winkler(&k as &str, &name as &str);
+			if conf < 0.8 {
+				return;
+			}
+			heap.push((conf, k));
+		});
+		heap.sort_by(|a, b| b.0.partial_cmp(&a.0).unwrap_or(Ordering::Equal));
+
+		throw!(VariableIsNotDefined(
+			name,
+			heap.into_iter().map(|(_, k)| k).collect()
+		))
 	}
 	pub fn contains_binding(&self, name: IStr) -> bool {
 		self.0.bindings.contains_key(&name)

--- a/crates/jrsonnet-evaluator/src/error.rs
+++ b/crates/jrsonnet-evaluator/src/error.rs
@@ -11,6 +11,30 @@
 	typed::TypeLocError,
 };
 
+fn format_found(list: &[IStr], what: &str) -> String {
+	if list.is_empty() {
+		return String::new();
+	}
+	let mut out = String::new();
+	out.push_str("\nThere is ");
+	out.push_str(what);
+	if list.len() > 1 {
+		out.push('s');
+	}
+	out.push_str(" with similar name");
+	if list.len() > 1 {
+		out.push('s');
+	}
+	out.push_str(" present: ");
+	for (i, v) in list.iter().enumerate() {
+		if i != 0 {
+			out.push_str(", ");
+		}
+		out.push_str(v as &str);
+	}
+	out
+}
+
 #[derive(Error, Debug, Clone, Trace)]
 pub enum Error {
 	#[error("intrinsic not found: {0}")]
@@ -39,15 +63,15 @@
 	#[error("assert failed: {0}")]
 	AssertionFailed(IStr),
 
-	#[error("variable is not defined: {0}")]
-	VariableIsNotDefined(IStr),
+	#[error("variable is not defined: {0}{}", format_found(.1, "variable"))]
+	VariableIsNotDefined(IStr, Vec<IStr>),
 	#[error("duplicate local var: {0}")]
 	DuplicateLocalVar(IStr),
 
 	#[error("type mismatch: expected {}, got {2} {0}", .1.iter().map(|e| format!("{}", e)).collect::<Vec<_>>().join(", "))]
 	TypeMismatch(&'static str, Vec<ValType>, ValType),
-	#[error("no such field: {0}")]
-	NoSuchField(IStr),
+	#[error("no such field: {0}{}", format_found(.1, "field"))]
+	NoSuchField(IStr, Vec<IStr>),
 
 	#[error("only functions can be called, got {0}")]
 	OnlyFunctionsCanBeCalledGot(ValType),

--- a/crates/jrsonnet-evaluator/src/evaluate/mod.rs
+++ b/crates/jrsonnet-evaluator/src/evaluate/mod.rs
@@ -1,4 +1,4 @@
-use std::rc::Rc;
+use std::{cmp::Ordering, rc::Rc};
 
 use gcmodule::{Cc, Trace};
 use jrsonnet_interner::IStr;
@@ -450,7 +450,29 @@
 					|| format!("field <{}> access", key),
 					|| match v.get(s.clone(), key.clone()) {
 						Ok(Some(v)) => Ok(v),
-						Ok(None) => throw!(NoSuchField(key.clone())),
+						#[cfg(not(feature = "friendly-errors"))]
+						Ok(None) => throw!(NoSuchField(key.clone(), vec![])),
+						#[cfg(feature = "friendly-errors")]
+						Ok(None) => {
+							let mut heap = Vec::new();
+							for field in v.fields_ex(
+								true,
+								#[cfg(feature = "exp-preserve-order")]
+								false,
+							) {
+								let conf = strsim::jaro_winkler(&field as &str, &key as &str);
+								if conf < 0.8 {
+									continue;
+								}
+								heap.push((conf, field));
+							}
+							heap.sort_by(|a, b| b.0.partial_cmp(&a.0).unwrap_or(Ordering::Equal));
+
+							throw!(NoSuchField(
+								key.clone(),
+								heap.into_iter().map(|(_, v)| v).collect()
+							))
+						}
 						Err(e) if matches!(e.error(), MagicThisFileUsed) => {
 							Ok(Val::Str(loc.0.full_path().into()))
 						}
@@ -630,14 +652,14 @@
 			let path = s.resolve_file(&import_location, path as &str)?;
 			match i {
 				Import(_) => s.push(
-				CallLocation::new(loc),
+					CallLocation::new(loc),
 					|| format!("import {:?}", path.clone()),
 					|| s.import(path.clone()),
 				)?,
 				ImportStr(_) => Val::Str(s.import_str(path)?),
 				ImportBin(_) => Val::Arr(ArrValue::Bytes(s.import_bin(path)?)),
 				_ => unreachable!(),
-		}
+			}
 		}
 	})
 }