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

difftreelog

feat convert ParamName into enum

sytvpywqYaroslav Bolyukin2026-03-21parent: #b915f23.patch.diff
in: master

10 files changed

modifiedcrates/jrsonnet-evaluator/src/evaluate/destructure.rsdiffbeforeafterboth
--- 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)?;
 		}
modifiedcrates/jrsonnet-evaluator/src/evaluate/mod.rsdiffbeforeafterboth
--- 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),
 	}
 }
modifiedcrates/jrsonnet-evaluator/src/function/builtin.rsdiffbeforeafterboth
before · crates/jrsonnet-evaluator/src/function/builtin.rs
1use std::any::Any;2use std::fmt;34use jrsonnet_gcmodule::{cc_dyn, Acyclic, Trace, TraceBox};5use jrsonnet_interner::IStr;6use jrsonnet_parser::function::{FunctionSignature, ParamDefault, ParamName, ParamParse};78use super::{arglike::ArgsLike, parse::parse_builtin_call, CallLocation};9use crate::{Context, Result, Val};1011#[macro_export]12macro_rules! params {13	(@name unnamed) => { ParamName::ANONYMOUS };14	(@name named $name:literal) => { ParamName::new($crate::IStr::from($name)) };15	($($(#[$meta:meta])* [$kind:ident $(($lit:literal))? => $default:expr]),* $(,)?) => {16		thread_local! {17			static PARAMS: FunctionSignature = FunctionSignature::new([18				$($(#[$meta])* ParamParse::new(params!(@name $kind $($lit)?), $default)),*19			].into());20		}21	};22}2324cc_dyn!(25	#[derive(Clone)]26	BuiltinFunc,27	Builtin,28	pub(crate) fn new() {...}29);30impl Builtin for BuiltinFunc {31	fn name(&self) -> &str {32		self.0.name()33	}3435	fn params(&self) -> FunctionSignature {36		self.0.params()37	}3839	fn call(&self, ctx: Context, loc: CallLocation<'_>, args: &dyn ArgsLike) -> Result<Val> {40		self.0.call(ctx, loc, args)41	}4243	fn as_any(&self) -> &dyn Any {44		self.0.as_any()45	}46}4748/// Description of function defined by native code49///50/// Prefer to use #[builtin] macro, instead of manual implementation of this trait51pub trait Builtin: Trace {52	/// Function name to be used in stack traces53	fn name(&self) -> &str;54	/// Parameter names for named calls55	fn params(&self) -> FunctionSignature;56	/// Call the builtin57	fn call(&self, ctx: Context, loc: CallLocation<'_>, args: &dyn ArgsLike) -> Result<Val>;5859	fn as_any(&self) -> &dyn Any;60}6162pub trait StaticBuiltin: Builtin + Send + Sync63where64	Self: 'static,65{66	// In impl, to make it object safe:67	// const INST: &'static Self;68}6970#[derive(Trace)]71pub struct NativeCallback {72	pub(crate) params: FunctionSignature,73	handler: TraceBox<dyn NativeCallbackHandler>,74}75impl NativeCallback {76	#[deprecated = "prefer using builtins directly, use this interface only for bindings"]77	pub fn new(params: Vec<String>, handler: impl NativeCallbackHandler) -> Self {78		Self {79			params: FunctionSignature::new(80				params81					.into_iter()82					.map(|n| ParamParse::new(ParamName::new(n.into()), ParamDefault::None))83					.collect(),84			),85			handler: TraceBox(Box::new(handler)),86		}87	}88}8990impl Builtin for NativeCallback {91	fn name(&self) -> &str {92		// TODO: standard natives gets their names from definition93		// But builitins should already have them94		"<native>"95	}9697	fn params(&self) -> FunctionSignature {98		self.params.clone()99	}100101	fn call(&self, ctx: Context, _loc: CallLocation<'_>, args: &dyn ArgsLike) -> Result<Val> {102		let args = parse_builtin_call(ctx, self.params.clone(), args, true)?;103		let args = args104			.into_iter()105			.map(|a| a.expect("legacy natives have no default params"))106			.map(|a| a.evaluate())107			.collect::<Result<Vec<Val>>>()?;108		self.handler.call(&args)109	}110111	fn as_any(&self) -> &dyn Any {112		self113	}114}115116pub trait NativeCallbackHandler: Trace {117	fn call(&self, args: &[Val]) -> Result<Val>;118}
modifiedcrates/jrsonnet-evaluator/src/function/mod.rsdiffbeforeafterboth
--- 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;
modifiedcrates/jrsonnet-evaluator/src/function/parse.rsdiffbeforeafterboth
--- 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;
 				}
modifiedcrates/jrsonnet-evaluator/src/function/prepared.rsdiffbeforeafterboth
--- 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.
modifiedcrates/jrsonnet-interner/src/lib.rsdiffbeforeafterboth
--- 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 {
modifiedcrates/jrsonnet-parser/src/expr.rsdiffbeforeafterboth
--- 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")]
modifiedcrates/jrsonnet-parser/src/function.rsdiffbeforeafterboth
--- a/crates/jrsonnet-parser/src/function.rs
+++ b/crates/jrsonnet-parser/src/function.rs
@@ -6,32 +6,38 @@
 use jrsonnet_interner::IStr;
 
 #[derive(Clone, Acyclic, Debug, PartialEq, Eq)]
-pub struct ParamName(pub Option<IStr>);
+pub enum ParamName {
+	Unnamed,
+	Named(IStr),
+}
 impl ParamName {
-	pub const ANONYMOUS: Self = Self(None);
-	pub fn new(name: IStr) -> Self {
-		Self(Some(name))
-	}
 	pub fn as_str(&self) -> Option<&str> {
-		self.0.as_deref()
+		match self {
+			ParamName::Unnamed => None,
+			ParamName::Named(istr) => Some(istr),
+		}
 	}
 	pub fn is_anonymous(&self) -> bool {
-		self.0.is_none()
+		matches!(self, Self::Unnamed)
+	}
+	pub fn is_named(&self) -> bool {
+		matches!(self, Self::Named(_))
 	}
 }
 impl PartialEq<IStr> for ParamName {
 	fn eq(&self, other: &IStr) -> bool {
-		self.0
-			.as_ref()
-			.map_or(false, |s| s.as_bytes() == other.as_bytes())
+		match self {
+			ParamName::Unnamed => false,
+			ParamName::Named(istr) => istr == other,
+		}
 	}
 }
 
 impl fmt::Display for ParamName {
 	fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-		match &self.0 {
-			Some(v) => write!(f, "{v}"),
-			None => write!(f, "<unnamed>"),
+		match &self {
+			Self::Named(v) => write!(f, "{v}"),
+			Self::Unnamed => write!(f, "<unnamed>"),
 		}
 	}
 }
modifiedcrates/jrsonnet-parser/src/snapshots/jrsonnet_parser__tests__default_param_before_nondefault.snapdiffbeforeafterboth
--- 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,
                         },