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

5use crate::{5use crate::{
6	bail,6	bail,
7	error::{ErrorKind::*, Result},7	error::{ErrorKind::*, Result},
8	evaluate, evaluate_method, evaluate_named, Context, Pending, Thunk, Val,8	evaluate_method, evaluate_named_param, Context, Pending, Thunk, Val,
9};9};
1010
11#[allow(clippy::too_many_lines)]11#[allow(clippy::too_many_lines)]
170			let value = value.clone();170			let value = value.clone();
171			let data = {171			let data = {
172				let fctx = fctx.clone();172				let fctx = fctx.clone();
173				Thunk!(move || name.0.map_or_else(173				Thunk!(move || evaluate_named_param(fctx.unwrap(), &value, name))
174					|| evaluate(fctx.unwrap(), &value),
175					|name| evaluate_named(fctx.unwrap(), &value, name),
176				))
177			};174			};
178			destruct(into, data, fctx, new_bindings)?;175			destruct(into, data, fctx, new_bindings)?;

380}380}
381381
382pub fn evaluate_named_param(ctx: Context, expr: &Spanned<Expr>, name: ParamName) -> Result<Val> {382pub fn evaluate_named_param(ctx: Context, expr: &Spanned<Expr>, name: ParamName) -> Result<Val> {
383	match name.0 {383	match name {
384		Some(name) => evaluate_named(ctx, expr, name),384		ParamName::Named(name) => evaluate_named(ctx, expr, name),
385		None => evaluate(ctx, expr),385		ParamName::Unnamed => evaluate(ctx, expr),
386	}386	}
387}387}
388388

1use std::any::Any;1use std::any::Any;
2use std::fmt;
32
4use jrsonnet_gcmodule::{cc_dyn, Acyclic, Trace, TraceBox};3use jrsonnet_gcmodule::{cc_dyn, Trace, TraceBox};
5use jrsonnet_interner::IStr;
6use jrsonnet_parser::function::{FunctionSignature, ParamDefault, ParamName, ParamParse};4use jrsonnet_parser::function::{FunctionSignature, ParamDefault, ParamName, ParamParse};
75
8use super::{arglike::ArgsLike, parse::parse_builtin_call, CallLocation};6use super::{arglike::ArgsLike, parse::parse_builtin_call, CallLocation};
9use crate::{Context, Result, Val};7use crate::{Context, Result, Val};
108
11#[macro_export]9#[macro_export]
12macro_rules! params {10macro_rules! params {
13	(@name unnamed) => { ParamName::ANONYMOUS };11	(@name unnamed) => { ParamName::Unnamed };
14	(@name named $name:literal) => { ParamName::new($crate::IStr::from($name)) };12	(@name named $name:literal) => { ParamName::Named($crate::IStr::from($name)) };
15	($($(#[$meta:meta])* [$kind:ident $(($lit:literal))? => $default:expr]),* $(,)?) => {13	($($(#[$meta:meta])* [$kind:ident $(($lit:literal))? => $default:expr]),* $(,)?) => {
16		thread_local! {14		thread_local! {
17			static PARAMS: FunctionSignature = FunctionSignature::new([15			static PARAMS: FunctionSignature = FunctionSignature::new([
79			params: FunctionSignature::new(77			params: FunctionSignature::new(
80				params78				params
81					.into_iter()79					.into_iter()
82					.map(|n| ParamParse::new(ParamName::new(n.into()), ParamDefault::None))80					.map(|n| ParamParse::new(ParamName::Named(n.into()), ParamDefault::None))
83					.collect(),81					.collect(),
84			),82			),
85			handler: TraceBox(Box::new(handler)),83			handler: TraceBox(Box::new(handler)),
88}86}
8987
90impl Builtin for NativeCallback {88impl Builtin for NativeCallback {
91	fn name(&self) -> &str {89	fn name(&self) -> &'static str {
92		// TODO: standard natives gets their names from definition90		// TODO: standard natives gets their names from definition
93		// But builitins should already have them91		// But builitins should already have them
94		"<native>"92		"<native>"

14	parse::{parse_default_function_call, parse_function_call},14	parse::{parse_default_function_call, parse_function_call},
15};15};
16use crate::{16use crate::{
17	bail, error::ErrorKind::*, evaluate, evaluate_trivial, function::builtin::BuiltinFunc, params,17	bail, error::ErrorKind::*, evaluate, evaluate_trivial, function::builtin::BuiltinFunc, Context,
18	Context, ContextBuilder, Result, Thunk, Val,18	ContextBuilder, Result, Thunk, Val,
19};19};
2020

1use std::mem::replace;1use std::mem::replace;
22
3use jrsonnet_interner::IStr;
4use jrsonnet_parser::{function::FunctionSignature, ExprParams};3use jrsonnet_parser::{
4	function::{FunctionSignature, ParamName},
5	ExprParams,
6};
5use rustc_hash::FxHashMap;7use rustc_hash::FxHashMap;
68
9	bail,11	bail,
10	destructure::destruct,12	destructure::destruct,
11	error::{ErrorKind::*, Result},13	error::{ErrorKind::*, Result},
12	evaluate_named, evaluate_named_param,14	evaluate_named_param,
13	gc::WithCapacityExt as _,15	gc::WithCapacityExt as _,
14	Context, Pending, Thunk, Val,16	Context, Pending, Thunk, Val,
15};17};
76			.enumerate()78			.enumerate()
77			.filter_map(|(i, p)| Some((i, &p.destruct, p.default.as_ref()?)))79			.filter_map(|(i, p)| Some((i, &p.destruct, p.default.as_ref()?)))
78		{80		{
79			if let Some(name) = into.name().0 {81			if let ParamName::Named(name) = into.name() {
80				if passed_args.contains_key(&name) {82				if passed_args.contains_key(&name) {
81					continue;83					continue;
82				}84				}

44
5use crate::destructure::destruct;5use crate::destructure::destruct;
6use crate::gc::WithCapacityExt;6use crate::gc::WithCapacityExt;
7use crate::val::ThunkValue as _;
8use crate::{bail, error::ErrorKind::*, Result};7use crate::{bail, error::ErrorKind::*, Result};
9use crate::{evaluate_named, evaluate_named_param, Context, ContextBuilder, Pending, Thunk, Val};8use crate::{evaluate_named_param, Context, ContextBuilder, Pending, Thunk, Val};
109
11pub struct PreparedCall {10pub struct PreparedCall {
12	// Param, named input.11	// Param, named input.

32	}32	}
33}33}
34
35/// SAFETY:
36///
37/// `IStr` is acyclic
34unsafe impl Acyclic for IStr {}38unsafe impl Acyclic for IStr {}
3539
36impl IStr {40impl IStr {

227impl Destruct {227impl Destruct {
228	/// Name of destructure, used for function parameter names228	/// Name of destructure, used for function parameter names
229	pub fn name(&self) -> ParamName {229	pub fn name(&self) -> ParamName {
230		ParamName(match self {230		match self {
231			Self::Full(name) => Some(name.clone()),231			Self::Full(name) => ParamName::Named(name.clone()),
232			#[cfg(feature = "exp-destruct")]232			#[cfg(feature = "exp-destruct")]
233			_ => None,233			_ => ParamName::Unnamed,
234		})234		}
235	}235	}
236	pub fn binds_len(&self) -> usize {236	pub fn binds_len(&self) -> usize {
237		#[cfg(feature = "exp-destruct")]237		#[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}

28                signature: FunctionSignature(28                signature: FunctionSignature(
29                    [29                    [
30                        ParamParse {30                        ParamParse {
31                            name: ParamName(31                            name: Named(
32                                Some(32                                "foo",
33                                    "foo",
34                                ),
35                            ),33                            ),
36                            default: Exists,34                            default: Exists,
37                        },35                        },
38                        ParamParse {36                        ParamParse {
39                            name: ParamName(37                            name: Named(
40                                Some(38                                "bar",
41                                    "bar",
42                                ),
43                            ),39                            ),
44                            default: None,40                            default: None,
45                        },41                        },