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

--- 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")]

--- 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>"),
 		}
 	}
 }

--- 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,
                         },