git.delta.rocks / jrsonnet / refs/commits / b3f009bb7b2e

--- a/crates/jrsonnet-evaluator/src/evaluate/destructure.rs
+++ b/crates/jrsonnet-evaluator/src/evaluate/destructure.rs
@@ -5,7 +5,7 @@
 use crate::{
 	bail,
 	error::{ErrorKind::*, Result},
-	evaluate, evaluate_method, evaluate_named, Context, Pending, Thunk, Val,
+	evaluate_method, evaluate_named_param, Context, Pending, Thunk, Val,
 };
 
 #[allow(clippy::too_many_lines)]
@@ -170,10 +170,7 @@
 			let value = value.clone();
 			let data = {
 				let fctx = fctx.clone();
-				Thunk!(move || name.0.map_or_else(
-					|| evaluate(fctx.unwrap(), &value),
-					|name| evaluate_named(fctx.unwrap(), &value, name),
-				))
+				Thunk!(move || evaluate_named_param(fctx.unwrap(), &value, name))
 			};
 			destruct(into, data, fctx, new_bindings)?;
 		}

--- a/crates/jrsonnet-evaluator/src/evaluate/mod.rs
+++ b/crates/jrsonnet-evaluator/src/evaluate/mod.rs
@@ -380,9 +380,9 @@
 }
 
 pub fn evaluate_named_param(ctx: Context, expr: &Spanned<Expr>, name: ParamName) -> Result<Val> {
-	match name.0 {
-		Some(name) => evaluate_named(ctx, expr, name),
-		None => evaluate(ctx, expr),
+	match name {
+		ParamName::Named(name) => evaluate_named(ctx, expr, name),
+		ParamName::Unnamed => evaluate(ctx, expr),
 	}
 }
 

--- a/crates/jrsonnet-evaluator/src/function/builtin.rs
+++ b/crates/jrsonnet-evaluator/src/function/builtin.rs
@@ -1,8 +1,6 @@
 use std::any::Any;
-use std::fmt;
 
-use jrsonnet_gcmodule::{cc_dyn, Acyclic, Trace, TraceBox};
-use jrsonnet_interner::IStr;
+use jrsonnet_gcmodule::{cc_dyn, Trace, TraceBox};
 use jrsonnet_parser::function::{FunctionSignature, ParamDefault, ParamName, ParamParse};
 
 use super::{arglike::ArgsLike, parse::parse_builtin_call, CallLocation};
@@ -10,8 +8,8 @@
 
 #[macro_export]
 macro_rules! params {
-	(@name unnamed) => { ParamName::ANONYMOUS };
-	(@name named $name:literal) => { ParamName::new($crate::IStr::from($name)) };
+	(@name unnamed) => { ParamName::Unnamed };
+	(@name named $name:literal) => { ParamName::Named($crate::IStr::from($name)) };
 	($($(#[$meta:meta])* [$kind:ident $(($lit:literal))? => $default:expr]),* $(,)?) => {
 		thread_local! {
 			static PARAMS: FunctionSignature = FunctionSignature::new([
@@ -79,7 +77,7 @@
 			params: FunctionSignature::new(
 				params
 					.into_iter()
-					.map(|n| ParamParse::new(ParamName::new(n.into()), ParamDefault::None))
+					.map(|n| ParamParse::new(ParamName::Named(n.into()), ParamDefault::None))
 					.collect(),
 			),
 			handler: TraceBox(Box::new(handler)),
@@ -88,7 +86,7 @@
 }
 
 impl Builtin for NativeCallback {
-	fn name(&self) -> &str {
+	fn name(&self) -> &'static str {
 		// TODO: standard natives gets their names from definition
 		// But builitins should already have them
 		"<native>"

--- a/crates/jrsonnet-evaluator/src/function/mod.rs
+++ b/crates/jrsonnet-evaluator/src/function/mod.rs
@@ -14,8 +14,8 @@
 	parse::{parse_default_function_call, parse_function_call},
 };
 use crate::{
-	bail, error::ErrorKind::*, evaluate, evaluate_trivial, function::builtin::BuiltinFunc, params,
-	Context, ContextBuilder, Result, Thunk, Val,
+	bail, error::ErrorKind::*, evaluate, evaluate_trivial, function::builtin::BuiltinFunc, Context,
+	ContextBuilder, Result, Thunk, Val,
 };
 
 pub mod arglike;

--- a/crates/jrsonnet-evaluator/src/function/parse.rs
+++ b/crates/jrsonnet-evaluator/src/function/parse.rs
@@ -1,7 +1,9 @@
 use std::mem::replace;
 
-use jrsonnet_interner::IStr;
-use jrsonnet_parser::{function::FunctionSignature, ExprParams};
+use jrsonnet_parser::{
+	function::{FunctionSignature, ParamName},
+	ExprParams,
+};
 use rustc_hash::FxHashMap;
 
 use super::arglike::ArgsLike;
@@ -9,7 +11,7 @@
 	bail,
 	destructure::destruct,
 	error::{ErrorKind::*, Result},
-	evaluate_named, evaluate_named_param,
+	evaluate_named_param,
 	gc::WithCapacityExt as _,
 	Context, Pending, Thunk, Val,
 };
@@ -76,7 +78,7 @@
 			.enumerate()
 			.filter_map(|(i, p)| Some((i, &p.destruct, p.default.as_ref()?)))
 		{
-			if let Some(name) = into.name().0 {
+			if let ParamName::Named(name) = into.name() {
 				if passed_args.contains_key(&name) {
 					continue;
 				}

--- a/crates/jrsonnet-evaluator/src/function/prepared.rs
+++ b/crates/jrsonnet-evaluator/src/function/prepared.rs
@@ -4,9 +4,8 @@
 
 use crate::destructure::destruct;
 use crate::gc::WithCapacityExt;
-use crate::val::ThunkValue as _;
 use crate::{bail, error::ErrorKind::*, Result};
-use crate::{evaluate_named, evaluate_named_param, Context, ContextBuilder, Pending, Thunk, Val};
+use crate::{evaluate_named_param, Context, ContextBuilder, Pending, Thunk, Val};
 
 pub struct PreparedCall {
 	// Param, named input.

--- a/crates/jrsonnet-interner/src/lib.rs
+++ b/crates/jrsonnet-interner/src/lib.rs
@@ -31,6 +31,10 @@
 		false
 	}
 }
+
+/// SAFETY:
+///
+/// `IStr` is acyclic
 unsafe impl Acyclic for IStr {}
 
 impl IStr {

--- a/crates/jrsonnet-parser/src/expr.rs
+++ b/crates/jrsonnet-parser/src/expr.rs
@@ -227,11 +227,11 @@
 impl Destruct {
 	/// Name of destructure, used for function parameter names
 	pub fn name(&self) -> ParamName {
-		ParamName(match self {
-			Self::Full(name) => Some(name.clone()),
+		match self {
+			Self::Full(name) => ParamName::Named(name.clone()),
 			#[cfg(feature = "exp-destruct")]
-			_ => None,
-		})
+			_ => ParamName::Unnamed,
+		}
 	}
 	pub fn binds_len(&self) -> usize {
 		#[cfg(feature = "exp-destruct")]

6use jrsonnet_interner::IStr;6use jrsonnet_interner::IStr;
77
8#[derive(Clone, Acyclic, Debug, PartialEq, Eq)]8#[derive(Clone, Acyclic, Debug, PartialEq, Eq)]
9pub struct ParamName(pub Option<IStr>);9pub enum ParamName {
10	Unnamed,
11	Named(IStr),
12}
10impl ParamName {13impl ParamName {
11	pub const ANONYMOUS: Self = Self(None);
12	pub fn new(name: IStr) -> Self {14	pub fn as_str(&self) -> Option<&str> {
15		match self {
16			ParamName::Unnamed => None,
13		Self(Some(name))17			ParamName::Named(istr) => Some(istr),
18		}
14	}19	}
15	pub fn as_str(&self) -> Option<&str> {20	pub fn is_anonymous(&self) -> bool {
16		self.0.as_deref()21		matches!(self, Self::Unnamed)
17	}22	}
18	pub fn is_anonymous(&self) -> bool {23	pub fn is_named(&self) -> bool {
19		self.0.is_none()24		matches!(self, Self::Named(_))
20	}25	}
21}26}
22impl PartialEq<IStr> for ParamName {27impl PartialEq<IStr> for ParamName {
23	fn eq(&self, other: &IStr) -> bool {28	fn eq(&self, other: &IStr) -> bool {
24		self.029		match self {
25			.as_ref()
26			.map_or(false, |s| s.as_bytes() == other.as_bytes())30			ParamName::Unnamed => false,
31			ParamName::Named(istr) => istr == other,
32		}
27	}33	}
28}34}
2935
30impl fmt::Display for ParamName {36impl fmt::Display for ParamName {
31	fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {37	fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
32		match &self.0 {38		match &self {
33			Some(v) => write!(f, "{v}"),39			Self::Named(v) => write!(f, "{v}"),
34			None => write!(f, "<unnamed>"),40			Self::Unnamed => write!(f, "<unnamed>"),
35		}41		}
36	}42	}
37}43}

--- a/crates/jrsonnet-parser/src/snapshots/jrsonnet_parser__tests__default_param_before_nondefault.snap
+++ b/crates/jrsonnet-parser/src/snapshots/jrsonnet_parser__tests__default_param_before_nondefault.snap
@@ -28,18 +28,14 @@
                 signature: FunctionSignature(
                     [
                         ParamParse {
-                            name: ParamName(
-                                Some(
-                                    "foo",
-                                ),
+                            name: Named(
+                                "foo",
                             ),
                             default: Exists,
                         },
                         ParamParse {
-                            name: ParamName(
-                                Some(
-                                    "bar",
-                                ),
+                            name: Named(
+                                "bar",
                             ),
                             default: None,
                         },