git.delta.rocks / jrsonnet / refs/commits / 3f8fb69418f4

--- a/crates/jrsonnet-evaluator/src/builtin/format.rs
+++ b/crates/jrsonnet-evaluator/src/builtin/format.rs
@@ -314,7 +314,7 @@
 	for _ in 0..zp2 {
 		out.push('0');
 	}
-	out.push_str(&prefix);
+	out.push_str(prefix);
 
 	for digit in digits.into_iter().rev() {
 		let ch = NUMBERS[digit as usize] as char;
@@ -399,7 +399,10 @@
 		}
 		return;
 	}
-	let frac = (n.fract() * 10.0_f64.powf(precision as f64) + 0.5).floor();
+	let frac = n
+		.fract()
+		.mul_add(10.0_f64.powf(precision as f64), 0.5)
+		.floor();
 	if trailing || frac > 0.0 {
 		out.push('.');
 		let mut frac_str = String::new();
@@ -605,7 +608,7 @@
 }
 
 pub fn format_arr(str: &str, mut values: &[Val]) -> Result<String> {
-	let codes = parse_codes(&str)?;
+	let codes = parse_codes(str)?;
 	let mut out = String::new();
 
 	for code in codes {
@@ -659,7 +662,7 @@
 }
 
 pub fn format_obj(str: &str, values: &ObjValue) -> Result<String> {
-	let codes = parse_codes(&str)?;
+	let codes = parse_codes(str)?;
 	let mut out = String::new();
 
 	for code in codes {

--- a/crates/jrsonnet-evaluator/src/builtin/manifest.rs
+++ b/crates/jrsonnet-evaluator/src/builtin/manifest.rs
@@ -20,7 +20,7 @@
 	pub mtype: ManifestType,
 }
 
-pub(crate) fn manifest_json_ex(val: &Val, options: &ManifestJsonOptions<'_>) -> Result<String> {
+pub fn manifest_json_ex(val: &Val, options: &ManifestJsonOptions<'_>) -> Result<String> {
 	let mut out = String::new();
 	manifest_json_ex_buf(val, &mut out, &mut String::new(), options)?;
 	Ok(out)

--- a/crates/jrsonnet-evaluator/src/builtin/mod.rs
+++ b/crates/jrsonnet-evaluator/src/builtin/mod.rs
@@ -16,6 +16,7 @@
 pub mod manifest;
 pub mod sort;
 
+#[allow(clippy::cognitive_complexity)]
 pub fn call_builtin(
 	context: Context,
 	loc: &Option<ExprLocation>,
@@ -23,7 +24,7 @@
 	name: &str,
 	args: &ArgsDesc,
 ) -> Result<Val> {
-	Ok(match (ns, &name as &str) {
+	Ok(match (ns, name as &str) {
 		// arr/string/function
 		("std", "length") => parse_args!(context, "std.length", args, 1, [
 			0, x: [Val::Str|Val::Arr|Val::Obj], vec![ValType::Str, ValType::Arr, ValType::Obj];

--- a/crates/jrsonnet-evaluator/src/builtin/stdlib.rs
+++ b/crates/jrsonnet-evaluator/src/builtin/stdlib.rs
@@ -22,7 +22,7 @@
 		}
 
 		jrsonnet_parser::parse(
-			&jrsonnet_stdlib::STDLIB_STR,
+			jrsonnet_stdlib::STDLIB_STR,
 			&ParserSettings {
 				loc_data: true,
 				file_name: Rc::new(PathBuf::from("std.jsonnet")),

--- a/crates/jrsonnet-evaluator/src/ctx.rs
+++ b/crates/jrsonnet-evaluator/src/ctx.rs
@@ -48,8 +48,8 @@
 		&self.0.super_obj
 	}
 
-	pub fn new() -> Context {
-		Context(Rc::new(ContextInternals {
+	pub fn new() -> Self {
+		Self(Rc::new(ContextInternals {
 			dollar: None,
 			this: None,
 			super_obj: None,
@@ -65,14 +65,14 @@
 			.cloned()
 			.ok_or_else(|| UnknownVariable(name))?)
 	}
-	pub fn into_future(self, ctx: FutureContext) -> Context {
+	pub fn into_future(self, ctx: FutureContext) -> Self {
 		{
 			ctx.0.borrow_mut().replace(self);
 		}
 		ctx.unwrap()
 	}
 
-	pub fn with_var(self, name: Rc<str>, value: Val) -> Context {
+	pub fn with_var(self, name: Rc<str>, value: Val) -> Self {
 		let mut new_bindings =
 			FxHashMap::with_capacity_and_hasher(1, BuildHasherDefault::default());
 		new_bindings.insert(name, resolved_lazy_val!(value));
@@ -85,7 +85,7 @@
 		new_dollar: Option<ObjValue>,
 		new_this: Option<ObjValue>,
 		new_super_obj: Option<ObjValue>,
-	) -> Context {
+	) -> Self {
 		match Rc::try_unwrap(self.0) {
 			Ok(mut ctx) => {
 				// Extended context aren't used by anything else, we can freely mutate it without cloning
@@ -101,7 +101,7 @@
 				if !new_bindings.is_empty() {
 					ctx.bindings = ctx.bindings.extend(new_bindings);
 				}
-				Context(Rc::new(ctx))
+				Self(Rc::new(ctx))
 			}
 			Err(ctx) => {
 				let dollar = new_dollar.or_else(|| ctx.dollar.clone());
@@ -112,7 +112,7 @@
 				} else {
 					ctx.bindings.clone().extend(new_bindings)
 				};
-				Context(Rc::new(ContextInternals {
+				Self(Rc::new(ContextInternals {
 					dollar,
 					this,
 					super_obj,
@@ -127,7 +127,7 @@
 		new_dollar: Option<ObjValue>,
 		new_this: Option<ObjValue>,
 		new_super_obj: Option<ObjValue>,
-	) -> Result<Context> {
+	) -> Result<Self> {
 		let this = new_this.or_else(|| self.0.this.clone());
 		let super_obj = new_super_obj.or_else(|| self.0.super_obj.clone());
 		let mut new =

--- a/crates/jrsonnet-evaluator/src/error.rs
+++ b/crates/jrsonnet-evaluator/src/error.rs
@@ -95,10 +95,10 @@
 		Self(Box::new((e, StackTrace(vec![]))))
 	}
 
-	pub fn error(&self) -> &Error {
+	pub const fn error(&self) -> &Error {
 		&(self.0).0
 	}
-	pub fn trace(&self) -> &StackTrace {
+	pub const fn trace(&self) -> &StackTrace {
 		&(self.0).1
 	}
 	pub fn trace_mut(&mut self) -> &mut StackTrace {

--- a/crates/jrsonnet-evaluator/src/evaluate.rs
+++ b/crates/jrsonnet-evaluator/src/evaluate.rs
@@ -82,9 +82,9 @@
 	})
 }
 
-pub(crate) fn evaluate_add_op(a: &Val, b: &Val) -> Result<Val> {
+pub fn evaluate_add_op(a: &Val, b: &Val) -> Result<Val> {
 	Ok(match (a, b) {
-		(Val::Str(v1), Val::Str(v2)) => Val::Str(((**v1).to_owned() + &v2).into()),
+		(Val::Str(v1), Val::Str(v2)) => Val::Str(((**v1).to_owned() + v2).into()),
 
 		// Can't use generic json serialization way, because it depends on number to string concatenation (std.jsonnet:890)
 		(Val::Num(n), Val::Str(o)) => Val::Str(format!("{}{}", n, o).into()),
@@ -111,7 +111,7 @@
 	b: &LocExpr,
 ) -> Result<Val> {
 	Ok(
-		match (evaluate(context.clone(), &a)?.unwrap_if_lazy()?, op, b) {
+		match (evaluate(context.clone(), a)?.unwrap_if_lazy()?, op, b) {
 			(Val::Bool(true), BinaryOpType::Or, _o) => Val::Bool(true),
 			(Val::Bool(false), BinaryOpType::And, _o) => Val::Bool(false),
 			(a, op, eb) => {
@@ -194,14 +194,14 @@
 	Ok(match specs.get(0) {
 		None => Some(vec![value(context)?]),
 		Some(CompSpec::IfSpec(IfSpecData(cond))) => {
-			if evaluate(context.clone(), &cond)?.try_cast_bool("if spec")? {
+			if evaluate(context.clone(), cond)?.try_cast_bool("if spec")? {
 				evaluate_comp(context, value, &specs[1..])?
 			} else {
 				None
 			}
 		}
 		Some(CompSpec::ForSpec(ForSpecData(var, expr))) => {
-			match evaluate(context.clone(), &expr)?.unwrap_if_lazy()? {
+			match evaluate(context.clone(), expr)?.unwrap_if_lazy()? {
 				Val::Arr(list) => {
 					let mut out = Vec::new();
 					for item in list.iter() {
@@ -258,7 +258,7 @@
 				visibility,
 				value,
 			}) => {
-				let name = evaluate_field_name(context.clone(), &name)?;
+				let name = evaluate_field_name(context.clone(), name)?;
 				if name.is_none() {
 					continue;
 				}
@@ -286,7 +286,7 @@
 				value,
 				..
 			}) => {
-				let name = evaluate_field_name(context.clone(), &name)?;
+				let name = evaluate_field_name(context.clone(), name)?;
 				if name.is_none() {
 					continue;
 				}
@@ -320,7 +320,7 @@
 
 pub fn evaluate_object(context: Context, object: &ObjBody) -> Result<ObjValue> {
 	Ok(match object {
-		ObjBody::MemberList(members) => evaluate_member_list_object(context, &members)?,
+		ObjBody::MemberList(members) => evaluate_member_list_object(context, members)?,
 		ObjBody::ObjComp(obj) => {
 			let future_this = FutureObjValue::new();
 			let mut new_members = HashMap::new();
@@ -437,7 +437,7 @@
 		Parened(e) => evaluate(context, e)?,
 		Str(v) => Val::Str(v.clone()),
 		Num(v) => Val::new_checked_num(*v)?,
-		BinaryOp(v1, o, v2) => evaluate_binary_op_special(context, &v1, *o, &v2)?,
+		BinaryOp(v1, o, v2) => evaluate_binary_op_special(context, v1, *o, v2)?,
 		UnaryOp(o, v) => evaluate_unary_op(*o, &evaluate(context, v)?)?,
 		Var(name) => push(
 			loc,
@@ -461,7 +461,7 @@
 				(Val::Obj(v), Val::Str(s)) => {
 					let sn = s.clone();
 					push(
-						&loc,
+						loc,
 						|| format!("field <{}> access", sn),
 						|| {
 							if let Some(v) = v.get(s.clone())? {
@@ -563,7 +563,7 @@
 				&value.1,
 				|| "assertion condition".to_owned(),
 				|| {
-					evaluate(context.clone(), &value)?
+					evaluate(context.clone(), value)?
 						.try_cast_bool("assertion condition should be of type `boolean`")
 				},
 			)?;
@@ -576,7 +576,7 @@
 			}
 		}
 		ErrorStmt(e) => push(
-			&loc,
+			loc,
 			|| "error statement".to_owned(),
 			|| {
 				throw!(RuntimeError(
@@ -610,7 +610,7 @@
 			push(
 				loc,
 				|| format!("import {:?}", path),
-				|| with_state(|s| s.import_file(&import_location, path)),
+				|| with_state(|s| s.import_file(import_location, path)),
 			)?
 		}
 		ImportStr(path) => {
@@ -620,7 +620,7 @@
 				.0;
 			let import_location = Rc::make_mut(&mut tmp);
 			import_location.pop();
-			Val::Str(with_state(|s| s.import_file_str(&import_location, path))?)
+			Val::Str(with_state(|s| s.import_file_str(import_location, path))?)
 		}
 		Literal(LiteralType::Super) => throw!(StandaloneSuper),
 	})

--- a/crates/jrsonnet-evaluator/src/function.rs
+++ b/crates/jrsonnet-evaluator/src/function.rs
@@ -75,7 +75,7 @@
 		let idx = params
 			.iter()
 			.position(|p| *p.0 == **name)
-			.ok_or_else(|| UnknownFunctionParameter((&name as &str).to_owned()))?;
+			.ok_or_else(|| UnknownFunctionParameter((name as &str).to_owned()))?;
 
 		if idx >= params.len() {
 			throw!(TooManyArgsFunctionHas(params.len()));
@@ -111,7 +111,7 @@
 	Ok(body_ctx.unwrap_or(ctx).extend(out, None, None, None))
 }
 
-pub(crate) fn place_args(
+pub fn place_args(
 	ctx: Context,
 	body_ctx: Option<Context>,
 	params: &ParamsDesc,

--- a/crates/jrsonnet-evaluator/src/import.rs
+++ b/crates/jrsonnet-evaluator/src/import.rs
@@ -41,6 +41,7 @@
 		panic!("`as_any($self)` is not supported by dummy resolver")
 	}
 }
+#[allow(clippy::use_self)]
 impl Default for Box<dyn ImportResolver> {
 	fn default() -> Self {
 		Box::new(DummyImportResolver)

--- a/crates/jrsonnet-evaluator/src/integrations/serde.rs
+++ b/crates/jrsonnet-evaluator/src/integrations/serde.rs
@@ -14,10 +14,10 @@
 	type Error = LocError;
 	fn try_from(v: &Val) -> Result<Self> {
 		Ok(match v {
-			Val::Bool(b) => Value::Bool(*b),
-			Val::Null => Value::Null,
-			Val::Str(s) => Value::String((&s as &str).into()),
-			Val::Num(n) => Value::Number(if n.fract() <= f64::EPSILON {
+			Val::Bool(b) => Self::Bool(*b),
+			Val::Null => Self::Null,
+			Val::Str(s) => Self::String((s as &str).into()),
+			Val::Num(n) => Self::Number(if n.fract() <= f64::EPSILON {
 				(*n as i64).into()
 			} else {
 				Number::from_f64(*n).expect("to json number")
@@ -28,7 +28,7 @@
 				for item in a.iter() {
 					out.push(item.try_into()?);
 				}
-				Value::Array(out)
+				Self::Array(out)
 			}
 			Val::Obj(o) => {
 				let mut out = Map::new();
@@ -38,7 +38,7 @@
 						(&o.get(key)?.expect("field exists")).try_into()?,
 					);
 				}
-				Value::Object(out)
+				Self::Object(out)
 			}
 			Val::Func(_) => throw!(RuntimeError("tried to manifest function".into())),
 		})
@@ -48,16 +48,16 @@
 impl From<&Value> for Val {
 	fn from(v: &Value) -> Self {
 		match v {
-			Value::Null => Val::Null,
-			Value::Bool(v) => Val::Bool(*v),
-			Value::Number(n) => Val::Num(n.as_f64().expect("as f64")),
-			Value::String(s) => Val::Str((s as &str).into()),
+			Value::Null => Self::Null,
+			Value::Bool(v) => Self::Bool(*v),
+			Value::Number(n) => Self::Num(n.as_f64().expect("as f64")),
+			Value::String(s) => Self::Str((s as &str).into()),
 			Value::Array(a) => {
 				let mut out = Vec::with_capacity(a.len());
 				for v in a {
 					out.push(v.into());
 				}
-				Val::Arr(Rc::new(out))
+				Self::Arr(Rc::new(out))
 			}
 			Value::Object(o) => {
 				let mut entries = HashMap::with_capacity(o.len());
@@ -72,7 +72,7 @@
 						},
 					);
 				}
-				Val::Obj(ObjValue::new(None, Rc::new(entries)))
+				Self::Obj(ObjValue::new(None, Rc::new(entries)))
 			}
 		}
 	}

--- a/crates/jrsonnet-evaluator/src/lib.rs
+++ b/crates/jrsonnet-evaluator/src/lib.rs
@@ -1,5 +1,6 @@
 #![cfg_attr(feature = "unstable", feature(stmt_expr_attributes))]
 #![allow(macro_expanded_macro_exports_accessed_by_absolute_paths)]
+#![warn(clippy::all, clippy::nursery)]
 
 mod builtin;
 mod ctx;
@@ -49,8 +50,8 @@
 impl LazyBinding {
 	pub fn evaluate(&self, this: Option<ObjValue>, super_obj: Option<ObjValue>) -> Result<LazyVal> {
 		match self {
-			LazyBinding::Bindable(v) => v(this, super_obj),
-			LazyBinding::Bound(v) => Ok(v.clone()),
+			Self::Bindable(v) => v(this, super_obj),
+			Self::Bound(v) => Ok(v.clone()),
 		}
 	}
 }
@@ -77,7 +78,7 @@
 }
 impl Default for EvaluationSettings {
 	fn default() -> Self {
-		EvaluationSettings {
+		Self {
 			max_stack: 200,
 			max_trace: 20,
 			globals: Default::default(),
@@ -130,7 +131,7 @@
 	f: impl FnOnce() -> Result<T>,
 ) -> Result<T> {
 	if let Some(v) = e {
-		with_state(|s| s.push(&v, frame_desc, f))
+		with_state(|s| s.push(v, frame_desc, f))
 	} else {
 		f()
 	}
@@ -359,10 +360,10 @@
 /// Raw methods evaluate passed values but don't perform TLA execution
 impl EvaluationState {
 	pub fn evaluate_file_raw(&self, name: &PathBuf) -> Result<Val> {
-		self.run_in_state(|| self.import_file(&std::env::current_dir().expect("cwd"), &name))
+		self.run_in_state(|| self.import_file(&std::env::current_dir().expect("cwd"), name))
 	}
 	pub fn evaluate_file_raw_nocwd(&self, name: &PathBuf) -> Result<Val> {
-		self.run_in_state(|| self.import_file(&PathBuf::from("."), &name))
+		self.run_in_state(|| self.import_file(&PathBuf::from("."), name))
 	}
 	/// Parses and evaluates the given snippet
 	pub fn evaluate_snippet_raw(&self, source: Rc<PathBuf>, code: Rc<str>) -> Result<Val> {

--- a/crates/jrsonnet-evaluator/src/map.rs
+++ b/crates/jrsonnet-evaluator/src/map.rs
@@ -15,10 +15,10 @@
 		match Rc::try_unwrap(self.0) {
 			Ok(mut map) => {
 				map.current.extend(new_layer);
-				LayeredHashMap(Rc::new(map))
+				Self(Rc::new(map))
 			}
-			Err(this) => LayeredHashMap(Rc::new(LayeredHashMapInternals {
-				parent: Some(LayeredHashMap(this)),
+			Err(this) => Self(Rc::new(LayeredHashMapInternals {
+				parent: Some(Self(this)),
 				current: new_layer,
 			})),
 		}
@@ -31,20 +31,20 @@
 	{
 		(self.0)
 			.current
-			.get(&key)
+			.get(key)
 			.or_else(|| self.0.parent.as_ref().and_then(|p| p.get(key)))
 	}
 }
 
 impl<K: Hash, V> Clone for LayeredHashMap<K, V> {
 	fn clone(&self) -> Self {
-		LayeredHashMap(self.0.clone())
+		Self(self.0.clone())
 	}
 }
 
 impl<K: Hash + Eq, V> Default for LayeredHashMap<K, V> {
 	fn default() -> Self {
-		LayeredHashMap(Rc::new(LayeredHashMapInternals {
+		Self(Rc::new(LayeredHashMapInternals {
 			parent: None,
 			current: FxHashMap::default(),
 		}))

--- a/crates/jrsonnet-evaluator/src/obj.rs
+++ b/crates/jrsonnet-evaluator/src/obj.rs
@@ -47,23 +47,20 @@
 }
 
 impl ObjValue {
-	pub fn new(
-		super_obj: Option<ObjValue>,
-		this_entries: Rc<HashMap<Rc<str>, ObjMember>>,
-	) -> ObjValue {
-		ObjValue(Rc::new(ObjValueInternals {
+	pub fn new(super_obj: Option<Self>, this_entries: Rc<HashMap<Rc<str>, ObjMember>>) -> Self {
+		Self(Rc::new(ObjValueInternals {
 			super_obj,
 			this_entries,
 			value_cache: RefCell::new(HashMap::new()),
 		}))
 	}
-	pub fn new_empty() -> ObjValue {
+	pub fn new_empty() -> Self {
 		Self::new(None, Rc::new(HashMap::new()))
 	}
-	pub fn with_super(&self, super_obj: ObjValue) -> ObjValue {
+	pub fn with_super(&self, super_obj: Self) -> Self {
 		match &self.0.super_obj {
-			None => ObjValue::new(Some(super_obj), self.0.this_entries.clone()),
-			Some(v) => ObjValue::new(Some(v.with_super(super_obj)), self.0.this_entries.clone()),
+			None => Self::new(Some(super_obj), self.0.this_entries.clone()),
+			Some(v) => Self::new(Some(v.with_super(super_obj)), self.0.this_entries.clone()),
 		}
 	}
 	pub fn enum_fields(&self, handler: &impl Fn(&Rc<str>, &Visibility)) {
@@ -71,7 +68,7 @@
 			s.enum_fields(handler);
 		}
 		for (name, member) in self.0.this_entries.iter() {
-			handler(&name, &member.visibility);
+			handler(name, &member.visibility);
 		}
 	}
 	pub fn fields_visibility(&self) -> IndexMap<Rc<str>, bool> {
@@ -107,7 +104,7 @@
 	pub fn get(&self, key: Rc<str>) -> Result<Option<Val>> {
 		Ok(self.get_raw(key, self)?)
 	}
-	pub(crate) fn get_raw(&self, key: Rc<str>, real_this: &ObjValue) -> Result<Option<Val>> {
+	pub(crate) fn get_raw(&self, key: Rc<str>, real_this: &Self) -> Result<Option<Val>> {
 		let cache_key = (key.clone(), Rc::as_ptr(&real_this.0) as usize);
 
 		if let Some(v) = self.0.value_cache.borrow().get(&cache_key) {
@@ -135,7 +132,7 @@
 			.insert(cache_key, value.clone());
 		Ok(value)
 	}
-	fn evaluate_this(&self, v: &ObjMember, real_this: &ObjValue) -> Result<Val> {
+	fn evaluate_this(&self, v: &ObjMember, real_this: &Self) -> Result<Val> {
 		Ok(v.invoke
 			.evaluate(Some(real_this.clone()), self.0.super_obj.clone())?
 			.evaluate()?)

--- a/crates/jrsonnet-evaluator/src/trace/mod.rs
+++ b/crates/jrsonnet-evaluator/src/trace/mod.rs
@@ -17,9 +17,9 @@
 impl PathResolver {
 	pub fn resolve(&self, from: &PathBuf) -> String {
 		match self {
-			PathResolver::FileName => from.file_name().unwrap().to_string_lossy().into_owned(),
-			PathResolver::Absolute => from.to_string_lossy().into_owned(),
-			PathResolver::Relative(base) => {
+			Self::FileName => from.file_name().unwrap().to_string_lossy().into_owned(),
+			Self::Absolute => from.to_string_lossy().into_owned(),
+			Self::Relative(base) => {
 				if from.is_relative() {
 					return from.to_string_lossy().into_owned();
 				}

25pub struct LazyVal(Rc<RefCell<LazyValInternals>>);25pub struct LazyVal(Rc<RefCell<LazyValInternals>>);
26impl LazyVal {26impl LazyVal {
27	pub fn new(f: Box<dyn Fn() -> Result<Val>>) -> Self {27	pub fn new(f: Box<dyn Fn() -> Result<Val>>) -> Self {
28		LazyVal(Rc::new(RefCell::new(LazyValInternals::Waiting(f))))28		Self(Rc::new(RefCell::new(LazyValInternals::Waiting(f))))
29	}29	}
30	pub fn new_resolved(val: Val) -> Self {30	pub fn new_resolved(val: Val) -> Self {
31		LazyVal(Rc::new(RefCell::new(LazyValInternals::Computed(val))))31		Self(Rc::new(RefCell::new(LazyValInternals::Computed(val))))
32	}32	}
33	pub fn evaluate(&self) -> Result<Val> {33	pub fn evaluate(&self) -> Result<Val> {
34		let new_value = match &*self.0.borrow() {34		let new_value = match &*self.0.borrow() {
84impl PartialEq for FuncVal {84impl PartialEq for FuncVal {
85	fn eq(&self, other: &Self) -> bool {85	fn eq(&self, other: &Self) -> bool {
86		match (self, other) {86		match (self, other) {
87			(FuncVal::Normal(a), FuncVal::Normal(b)) => a == b,87			(Self::Normal(a), Self::Normal(b)) => a == b,
88			(FuncVal::Intrinsic(ans, an), FuncVal::Intrinsic(bns, bn)) => ans == bns && an == bn,88			(Self::Intrinsic(ans, an), Self::Intrinsic(bns, bn)) => ans == bns && an == bn,
89			(FuncVal::NativeExt(an, _), FuncVal::NativeExt(bn, _)) => an == bn,89			(Self::NativeExt(an, _), Self::NativeExt(bn, _)) => an == bn,
90			(..) => false,90			(..) => false,
91		}91		}
92	}92	}
93}93}
94impl FuncVal {94impl FuncVal {
95	pub fn is_ident(&self) -> bool {95	pub fn is_ident(&self) -> bool {
96		matches!(&self, FuncVal::Intrinsic(ns, n) if ns as &str == "std" && n as &str == "id")96		matches!(&self, Self::Intrinsic(ns, n) if ns as &str == "std" && n as &str == "id")
97	}97	}
98	pub fn name(&self) -> Rc<str> {98	pub fn name(&self) -> Rc<str> {
99		match self {99		match self {
100			FuncVal::Normal(normal) => normal.name.clone(),100			Self::Normal(normal) => normal.name.clone(),
101			FuncVal::Intrinsic(ns, name) => format!("intrinsic.{}.{}", ns, name).into(),101			Self::Intrinsic(ns, name) => format!("intrinsic.{}.{}", ns, name).into(),
102			FuncVal::NativeExt(n, _) => format!("native.{}", n).into(),102			Self::NativeExt(n, _) => format!("native.{}", n).into(),
103		}103		}
104	}104	}
105	pub fn evaluate(105	pub fn evaluate(
110		tailstrict: bool,110		tailstrict: bool,
111	) -> Result<Val> {111	) -> Result<Val> {
112		match self {112		match self {
113			FuncVal::Normal(func) => {113			Self::Normal(func) => {
114				let ctx = parse_function_call(114				let ctx = parse_function_call(
115					call_ctx,115					call_ctx,
116					Some(func.ctx.clone()),116					Some(func.ctx.clone()),
120				)?;120				)?;
121				evaluate(ctx, &func.body)121				evaluate(ctx, &func.body)
122			}122			}
123			FuncVal::Intrinsic(ns, name) => call_builtin(call_ctx, loc, &ns, &name, args),123			Self::Intrinsic(ns, name) => call_builtin(call_ctx, loc, ns, name, args),
124			FuncVal::NativeExt(_name, handler) => {124			Self::NativeExt(_name, handler) => {
125				let args = parse_function_call(call_ctx, None, &handler.params, args, true)?;125				let args = parse_function_call(call_ctx, None, &handler.params, args, true)?;
126				let mut out_args = Vec::with_capacity(handler.params.len());126				let mut out_args = Vec::with_capacity(handler.params.len());
127				for p in handler.params.0.iter() {127				for p in handler.params.0.iter() {
139		tailstrict: bool,139		tailstrict: bool,
140	) -> Result<Val> {140	) -> Result<Val> {
141		match self {141		match self {
142			FuncVal::Normal(func) => {142			Self::Normal(func) => {
143				let ctx = parse_function_call_map(143				let ctx = parse_function_call_map(
144					call_ctx,144					call_ctx,
145					Some(func.ctx.clone()),145					Some(func.ctx.clone()),
149				)?;149				)?;
150				evaluate(ctx, &func.body)150				evaluate(ctx, &func.body)
151			}151			}
152			FuncVal::Intrinsic(_, _) => todo!(),152			Self::Intrinsic(_, _) => todo!(),
153			FuncVal::NativeExt(_, _) => todo!(),153			Self::NativeExt(_, _) => todo!(),
154		}154		}
155	}155	}
156156
157	pub fn evaluate_values(&self, call_ctx: Context, args: &[Val]) -> Result<Val> {157	pub fn evaluate_values(&self, call_ctx: Context, args: &[Val]) -> Result<Val> {
158		match self {158		match self {
159			FuncVal::Normal(func) => {159			Self::Normal(func) => {
160				let ctx = place_args(call_ctx, Some(func.ctx.clone()), &func.params, args)?;160				let ctx = place_args(call_ctx, Some(func.ctx.clone()), &func.params, args)?;
161				evaluate(ctx, &func.body)161				evaluate(ctx, &func.body)
162			}162			}
163			FuncVal::Intrinsic(_, _) => todo!(),163			Self::Intrinsic(_, _) => todo!(),
164			FuncVal::NativeExt(_, _) => todo!(),164			Self::NativeExt(_, _) => todo!(),
165		}165		}
166	}166	}
167}167}
177	Func,177	Func,
178}178}
179impl ValType {179impl ValType {
180	pub fn name(&self) -> &'static str {180	pub const fn name(&self) -> &'static str {
181		use ValType::*;181		use ValType::*;
182		match self {182		match self {
183			Bool => "boolean",183			Bool => "boolean",
227impl Val {227impl Val {
228	/// Creates `Val::Num` after checking for numeric overflow.228	/// Creates `Val::Num` after checking for numeric overflow.
229	/// As numbers are `f64`, we can just check for their finity.229	/// As numbers are `f64`, we can just check for their finity.
230	pub fn new_checked_num(num: f64) -> Result<Val> {230	pub fn new_checked_num(num: f64) -> Result<Self> {
231		if num.is_finite() {231		if num.is_finite() {
232			Ok(Val::Num(num))232			Ok(Self::Num(num))
233		} else {233		} else {
234			throw!(RuntimeError("overflow".into()))234			throw!(RuntimeError("overflow".into()))
235		}235		}
245	}245	}
246	pub fn try_cast_bool(self, context: &'static str) -> Result<bool> {246	pub fn try_cast_bool(self, context: &'static str) -> Result<bool> {
247		self.assert_type(context, ValType::Bool)?;247		self.assert_type(context, ValType::Bool)?;
248		Ok(matches_unwrap!(self.unwrap_if_lazy()?, Val::Bool(v), v))248		Ok(matches_unwrap!(self.unwrap_if_lazy()?, Self::Bool(v), v))
249	}249	}
250	pub fn try_cast_str(self, context: &'static str) -> Result<Rc<str>> {250	pub fn try_cast_str(self, context: &'static str) -> Result<Rc<str>> {
251		self.assert_type(context, ValType::Str)?;251		self.assert_type(context, ValType::Str)?;
252		Ok(matches_unwrap!(self.unwrap_if_lazy()?, Val::Str(v), v))252		Ok(matches_unwrap!(self.unwrap_if_lazy()?, Self::Str(v), v))
253	}253	}
254	pub fn try_cast_num(self, context: &'static str) -> Result<f64> {254	pub fn try_cast_num(self, context: &'static str) -> Result<f64> {
255		self.assert_type(context, ValType::Num)?;255		self.assert_type(context, ValType::Num)?;
256		Ok(matches_unwrap!(self.unwrap_if_lazy()?, Val::Num(v), v))256		Ok(matches_unwrap!(self.unwrap_if_lazy()?, Self::Num(v), v))
257	}257	}
258	pub fn inplace_unwrap(&mut self) -> Result<()> {258	pub fn inplace_unwrap(&mut self) -> Result<()> {
259		while let Val::Lazy(lazy) = self {259		while let Self::Lazy(lazy) = self {
260			*self = lazy.evaluate()?;260			*self = lazy.evaluate()?;
261		}261		}
262		Ok(())262		Ok(())
263	}263	}
264	pub fn unwrap_if_lazy(&self) -> Result<Self> {264	pub fn unwrap_if_lazy(&self) -> Result<Self> {
265		Ok(if let Val::Lazy(v) = self {265		Ok(if let Self::Lazy(v) = self {
266			v.evaluate()?.unwrap_if_lazy()?266			v.evaluate()?.unwrap_if_lazy()?
267		} else {267		} else {
268			self.clone()268			self.clone()
269		})269		})
270	}270	}
271	pub fn value_type(&self) -> Result<ValType> {271	pub fn value_type(&self) -> Result<ValType> {
272		Ok(match self {272		Ok(match self {
273			Val::Str(..) => ValType::Str,273			Self::Str(..) => ValType::Str,
274			Val::Num(..) => ValType::Num,274			Self::Num(..) => ValType::Num,
275			Val::Arr(..) => ValType::Arr,275			Self::Arr(..) => ValType::Arr,
276			Val::Obj(..) => ValType::Obj,276			Self::Obj(..) => ValType::Obj,
277			Val::Bool(_) => ValType::Bool,277			Self::Bool(_) => ValType::Bool,
278			Val::Null => ValType::Null,278			Self::Null => ValType::Null,
279			Val::Func(..) => ValType::Func,279			Self::Func(..) => ValType::Func,
280			Val::Lazy(_) => self.clone().unwrap_if_lazy()?.value_type()?,280			Self::Lazy(_) => self.clone().unwrap_if_lazy()?.value_type()?,
281		})281		})
282	}282	}
283283
284	pub fn to_string(&self) -> Result<Rc<str>> {284	pub fn to_string(&self) -> Result<Rc<str>> {
285		Ok(match self.unwrap_if_lazy()? {285		Ok(match self.unwrap_if_lazy()? {
286			Val::Bool(true) => "true".into(),286			Self::Bool(true) => "true".into(),
287			Val::Bool(false) => "false".into(),287			Self::Bool(false) => "false".into(),
288			Val::Null => "null".into(),288			Self::Null => "null".into(),
289			Val::Str(s) => s,289			Self::Str(s) => s,
290			v => manifest_json_ex(290			v => manifest_json_ex(
291				&v,291				&v,
292				&ManifestJsonOptions {292				&ManifestJsonOptions {
293					padding: &"",293					padding: "",
294					mtype: ManifestType::ToString,294					mtype: ManifestType::ToString,
295				},295				},
296			)?296			)?
301	/// Expects value to be object, outputs (key, manifested value) pairs301	/// Expects value to be object, outputs (key, manifested value) pairs
302	pub fn manifest_multi(&self, ty: &ManifestFormat) -> Result<Vec<(Rc<str>, Rc<str>)>> {302	pub fn manifest_multi(&self, ty: &ManifestFormat) -> Result<Vec<(Rc<str>, Rc<str>)>> {
303		let obj = match self {303		let obj = match self {
304			Val::Obj(obj) => obj,304			Self::Obj(obj) => obj,
305			_ => throw!(MultiManifestOutputIsNotAObject),305			_ => throw!(MultiManifestOutputIsNotAObject),
306		};306		};
307		let keys = obj.visible_fields();307		let keys = obj.visible_fields();
319	/// Expects value to be array, outputs manifested values319	/// Expects value to be array, outputs manifested values
320	pub fn manifest_stream(&self, ty: &ManifestFormat) -> Result<Vec<Rc<str>>> {320	pub fn manifest_stream(&self, ty: &ManifestFormat) -> Result<Vec<Rc<str>>> {
321		let arr = match self {321		let arr = match self {
322			Val::Arr(a) => a,322			Self::Arr(a) => a,
323			_ => throw!(StreamManifestOutputIsNotAArray),323			_ => throw!(StreamManifestOutputIsNotAArray),
324		};324		};
325		let mut out = Vec::with_capacity(arr.len());325		let mut out = Vec::with_capacity(arr.len());
333		Ok(match ty {333		Ok(match ty {
334			ManifestFormat::YamlStream(format) => {334			ManifestFormat::YamlStream(format) => {
335				let arr = match self {335				let arr = match self {
336					Val::Arr(a) => a,336					Self::Arr(a) => a,
337					_ => throw!(StreamManifestOutputIsNotAArray),337					_ => throw!(StreamManifestOutputIsNotAArray),
338				};338				};
339				let mut out = String::new();339				let mut out = String::new();
358			ManifestFormat::Yaml(padding) => self.to_yaml(*padding)?,358			ManifestFormat::Yaml(padding) => self.to_yaml(*padding)?,
359			ManifestFormat::Json(padding) => self.to_json(*padding)?,359			ManifestFormat::Json(padding) => self.to_json(*padding)?,
360			ManifestFormat::String => match self {360			ManifestFormat::String => match self {
361				Val::Str(s) => s.clone(),361				Self::Str(s) => s.clone(),
362				_ => throw!(StringManifestOutputIsNotAString),362				_ => throw!(StringManifestOutputIsNotAString),
363			},363			},
364		})364		})
384	#[cfg(feature = "faster")]384	#[cfg(feature = "faster")]
385	pub fn to_std_json(&self, padding: usize) -> Result<Rc<str>> {385	pub fn to_std_json(&self, padding: usize) -> Result<Rc<str>> {
386		manifest_json_ex(386		manifest_json_ex(
387			&self,387			self,
388			&ManifestJsonOptions {388			&ManifestJsonOptions {
389				padding: &" ".repeat(padding),389				padding: &" ".repeat(padding),
390				mtype: ManifestType::Std,390				mtype: ManifestType::Std,
441	}441	}
442}442}
443443
444fn is_function_like(val: &Val) -> bool {444const fn is_function_like(val: &Val) -> bool {
445	matches!(val, Val::Func(_))445	matches!(val, Val::Func(_))
446}446}
447447