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

73			.cloned()73			.cloned()
74			.ok_or(VariableIsNotDefined(name))?)74			.ok_or(VariableIsNotDefined(name))?)
75	}75	}
76	pub fn contains_binding(&self, name: IStr) -> bool {
77		self.0.bindings.contains_key(&name)
78	}
76	pub fn into_future(self, ctx: FutureWrapper<Self>) -> Self {79	pub fn into_future(self, ctx: FutureWrapper<Self>) -> Self {
77		{80		{
78			ctx.0.borrow_mut().replace(self);81			ctx.0.borrow_mut().replace(self);

56	BindingParameterASecondTime(IStr),56	BindingParameterASecondTime(IStr),
57	#[error("too many args, function has {0}")]57	#[error("too many args, function has {0}")]
58	TooManyArgsFunctionHas(usize),58	TooManyArgsFunctionHas(usize),
59	#[error("founction argument is not passed: {0}")]59	#[error("function argument is not passed: {0}")]
60	FunctionParameterNotBoundInCall(IStr),60	FunctionParameterNotBoundInCall(IStr),
6161
62	#[error("external variable is not defined: {0}")]62	#[error("external variable is not defined: {0}")]

1use crate::{error::Error::*, evaluate, throw, Context, LazyVal, LazyValValue, Result, Val};1use crate::{
2	error::Error::*, evaluate, evaluate_named, throw, Context, FutureWrapper, LazyVal,
3	LazyValValue, Result, Val,
4};
2use jrsonnet_gc::Trace;5use jrsonnet_gc::Trace;
3use jrsonnet_interner::IStr;6use jrsonnet_interner::IStr;
8const NO_DEFAULT_CONTEXT: &str =11const NO_DEFAULT_CONTEXT: &str =
9	"no default context set for call with defined default parameter value";12	"no default context set for call with defined default parameter value";
13
14#[derive(Trace)]
15#[trivially_drop]
16struct EvaluateLazyVal {
17	context: Context,
18	expr: LocExpr,
19}
20impl LazyValValue for EvaluateLazyVal {
21	fn get(self: Box<Self>) -> Result<Val> {
22		evaluate(self.context, &self.expr)
23	}
24}
1025
11/// Creates correct [context](Context) for function body evaluation returning error on invalid call.26/// Creates correct [context](Context) for function body evaluation returning error on invalid call.
12///27///
18/// * `tailstrict`: if set to `true` function arguments are eagerly executed, otherwise - lazily33/// * `tailstrict`: if set to `true` function arguments are eagerly executed, otherwise - lazily
19pub fn parse_function_call(34pub fn parse_function_call(
20	ctx: Context,35	ctx: Context,
21	body_ctx: Option<Context>,36	body_ctx: Context,
22	params: &ParamsDesc,37	params: &ParamsDesc,
23	args: &ArgsDesc,38	args: &ArgsDesc,
24	tailstrict: bool,39	tailstrict: bool,
25) -> Result<Context> {40) -> Result<Context> {
26	let mut out = HashMap::with_capacity_and_hasher(params.len(), BuildHasherDefault::default());41	let mut passed_args =
42		HashMap::with_capacity_and_hasher(params.len(), BuildHasherDefault::default());
43	if args.unnamed.len() > params.len() {
27	let mut positioned_args = vec![None; params.0.len()];44		throw!(TooManyArgsFunctionHas(params.len()))
45	}
46
47	let mut filled_args = 0;
48
28	for (id, arg) in args.iter().enumerate() {49	for (id, arg) in args.unnamed.iter().enumerate() {
50		let name = params[id].0.clone();
51		passed_args.insert(
52			name,
53			if tailstrict {
54				LazyVal::new_resolved(evaluate(ctx.clone(), arg)?)
55			} else {
56				LazyVal::new(Box::new(EvaluateLazyVal {
57					context: ctx.clone(),
58					expr: arg.clone(),
59				}))
60			},
61		);
62		filled_args += 1;
63	}
64
29		let idx = if let Some(name) = &arg.0 {65	for (name, value) in args.named.iter() {
66		// FIXME: O(n) for arg existence check
30			params67		if !params.iter().any(|p| &p.0 == name) {
31				.iter()68			throw!(UnknownFunctionParameter((name as &str).to_owned()));
32				.position(|p| *p.0 == *name)69		}
33				.ok_or_else(|| UnknownFunctionParameter(name.clone()))?70		if passed_args
71			.insert(
72				name.clone(),
73				if tailstrict {
74					LazyVal::new_resolved(evaluate(ctx.clone(), value)?)
75				} else {
76					LazyVal::new(Box::new(EvaluateLazyVal {
77						context: ctx.clone(),
78						expr: value.clone(),
79					}))
80				},
81			)
82			.is_some()
83		{
84			throw!(BindingParameterASecondTime(name.clone()));
85		}
86		filled_args += 1;
34		} else {87	}
35			id
36		};
3788
38		if idx >= params.len() {89	if filled_args < params.len() {
39			throw!(TooManyArgsFunctionHas(params.len()));90		// Some args are unset, but maybe we have defaults for them
40		}91		// Default values should be created in newly created context
41		if positioned_args[idx].is_some() {92		let future_context = FutureWrapper::<Context>::new();
42			throw!(BindingParameterASecondTime(params[idx].0.clone()));
43		}
44		positioned_args[idx] = Some(arg.1.clone());93		let mut defaults = HashMap::with_capacity_and_hasher(
45	}94			params.len() - filled_args,
46	// Fill defaults95			BuildHasherDefault::default(),
96		);
97
47	for (id, p) in params.iter().enumerate() {98		for param in params.iter().filter(|p| p.1.is_some()) {
48		let (ctx, expr) = if let Some(arg) = &positioned_args[id] {99			if passed_args.contains_key(&param.0.clone()) {
49			(ctx.clone(), arg)100				continue;
50		} else if let Some(default) = &p.1 {101			}
51			(body_ctx.clone().expect(NO_DEFAULT_CONTEXT), default)102			#[derive(Trace)]
52		} else {103			#[trivially_drop]
53			throw!(FunctionParameterNotBoundInCall(p.0.clone()));
54		};
55		let val = if tailstrict {104			struct LazyNamedBinding {
56			LazyVal::new_resolved(evaluate(ctx, expr)?)105				future_context: FutureWrapper<Context>,
106				name: IStr,
107				value: LocExpr,
57		} else {108			}
58			#[derive(Trace)]
59			#[trivially_drop]
60			struct EvaluateLazyVal {
61				context: Context,
62				expr: LocExpr,
63			}
64			impl LazyValValue for EvaluateLazyVal {109			impl LazyValValue for LazyNamedBinding {
65				fn get(self: Box<Self>) -> Result<Val> {110				fn get(self: Box<Self>) -> Result<Val> {
66					evaluate(self.context, &self.expr)111					evaluate_named(self.future_context.unwrap(), &self.value, self.name)
67				}112				}
68			}113			}
69
70			LazyVal::new(Box::new(EvaluateLazyVal {114			LazyVal::new(Box::new(LazyNamedBinding {
71				context: ctx.clone(),115				future_context: future_context.clone(),
72				expr: expr.clone(),116				name: param.0.clone(),
117				value: param.1.clone().unwrap(),
73			}))118			}));
74		};119
75		out.insert(p.0.clone(), val);120			defaults.insert(
121				param.0.clone(),
122				LazyVal::new(Box::new(LazyNamedBinding {
123					future_context: future_context.clone(),
124					name: param.0.clone(),
125					value: param.1.clone().unwrap(),
126				})),
127			);
128			filled_args += 1;
76	}129		}
130
131		// Some args still wasn't filled
132		if filled_args != params.len() {
133			for param in params.iter().skip(args.unnamed.len()) {
134				if !args.named.iter().any(|a| a.0 == param.0) {
135					throw!(FunctionParameterNotBoundInCall(param.0.clone()));
136				}
137			}
138			unreachable!();
139		}
77140
78	Ok(body_ctx.unwrap_or(ctx).extend(out, None, None, None))141		Ok(body_ctx
142			.extend(passed_args, None, None, None)
143			.extend_bound(defaults)
144			.into_future(future_context))
145	} else {
146		let body_ctx = body_ctx.extend(passed_args, None, None, None);
147		Ok(body_ctx)
148	}
79}149}
80150
81pub fn parse_function_call_map(151pub fn parse_function_call_map(
176		use $crate::{error::Error::*, throw, evaluate, push_stack_frame, typed::CheckType};246		use $crate::{error::Error::*, throw, evaluate, push_stack_frame, typed::CheckType};
177247
178		let args = $args;248		let args = $args;
179		if args.len() > $total_args {249		if args.unnamed.len() + args.named.len() > $total_args {
180			throw!(TooManyArgsFunctionHas($total_args));250			throw!(TooManyArgsFunctionHas($total_args));
181		}251		}
182		$(252		$(
183			if args.len() <= $id {253			if args.unnamed.len() + args.named.len() <= $id {
184				throw!(FunctionParameterNotBoundInCall(stringify!($name).into()));254				throw!(FunctionParameterNotBoundInCall(stringify!($name).into()));
185			}255			}
256			// Is named
186			let $name = &args[$id];257			let $name = if $id >= $args.unnamed.len() {
187			if $name.0.is_some() {258				let named = &args.named[$id - $args.unnamed.len()];
188				if $name.0.as_ref().unwrap() != stringify!($name) {259				if &named.0 != stringify!($name) {
189					throw!(IntrinsicArgumentReorderingIsNotSupportedYet);260					throw!(IntrinsicArgumentReorderingIsNotSupportedYet);
190				}261				}
191			}262				&named.1
263			} else {
264				&$args.unnamed[$id]
265			};
192			let $name = push_stack_frame(None, || format!("evaluating argument"), || {266			let $name = push_stack_frame(None, || format!("evaluating argument"), || {
193				let value = evaluate($ctx.clone(), &$name.1)?;267				let value = evaluate($ctx.clone(), &$name)?;
194				$ty.check(&value)?;268				$ty.check(&value)?;
195				Ok(value)269				Ok(value)
196			})?;270			})?;

30			.or_else(|| self.0.parent.as_ref().and_then(|p| p.get(key)))30			.or_else(|| self.0.parent.as_ref().and_then(|p| p.get(key)))
31	}31	}
32
33	pub fn contains_key(&self, key: &IStr) -> bool {
34		(self.0).current.contains_key(key)
35			|| self
36				.0
37				.parent
38				.as_ref()
39				.map(|p| p.contains_key(key))
40				.unwrap_or(false)
41	}
32}42}
3343
34impl Clone for LayeredHashMap {44impl Clone for LayeredHashMap {

11};11};
12use jrsonnet_gc::{Gc, GcCell, Trace};12use jrsonnet_gc::{Gc, GcCell, Trace};
13use jrsonnet_interner::IStr;13use jrsonnet_interner::IStr;
14use jrsonnet_parser::{el, Arg, ArgsDesc, Expr, ExprLocation, LiteralType, LocExpr, ParamsDesc};14use jrsonnet_parser::{el, ArgsDesc, Expr, ExprLocation, LiteralType, LocExpr, ParamsDesc};
15use jrsonnet_types::ValType;15use jrsonnet_types::ValType;
16use std::{collections::HashMap, fmt::Debug, rc::Rc};16use std::{collections::HashMap, fmt::Debug, rc::Rc};
1717
127			Self::Normal(func) => {127			Self::Normal(func) => {
128				let ctx = parse_function_call(128				let ctx = parse_function_call(
129					call_ctx,129					call_ctx,
130					Some(func.ctx.clone()),130					func.ctx.clone(),
131					&func.params,131					&func.params,
132					args,132					args,
133					tailstrict,133					tailstrict,
136			}136			}
137			Self::Intrinsic(name) => call_builtin(call_ctx, loc, name, args),137			Self::Intrinsic(name) => call_builtin(call_ctx, loc, name, args),
138			Self::NativeExt(_name, handler) => {138			Self::NativeExt(_name, handler) => {
139				let args = parse_function_call(call_ctx, None, &handler.params, args, true)?;139				let args =
140					parse_function_call(call_ctx, Context::new(), &handler.params, args, true)?;
140				let mut out_args = Vec::with_capacity(handler.params.len());141				let mut out_args = Vec::with_capacity(handler.params.len());
141				for p in handler.params.0.iter() {142				for p in handler.params.0.iter() {
142					out_args.push(args.binding(p.0.clone())?.evaluate()?);143					out_args.push(args.binding(p.0.clone())?.evaluate()?);
554						el!(Expr::Var("std".into())),555						el!(Expr::Var("std".into())),
555						el!(Expr::Str("manifestYamlDoc".into()))556						el!(Expr::Str("manifestYamlDoc".into()))
556					)),557					)),
557					ArgsDesc(vec![558					ArgsDesc::new(
559						vec![
558						Arg(None, el!(Expr::Var("__tmp__to_json__".into()))),560							el!(Expr::Var("__tmp__to_json__".into())),
559						Arg(
560							None,
561							el!(Expr::Literal(if padding != 0 {561							el!(Expr::Literal(if padding != 0 {
562								LiteralType::True562								LiteralType::True
563							} else {563							} else {
564								LiteralType::False564								LiteralType::False
565							}))565							})),
566						)
567					]),566						],
567						vec![]
568					),
568					false569					false
569				)),570				)),

194#[cfg_attr(feature = "deserialize", derive(Deserialize))]194#[cfg_attr(feature = "deserialize", derive(Deserialize))]
195#[derive(Debug, PartialEq, Trace)]195#[derive(Debug, PartialEq, Trace)]
196#[trivially_drop]196#[trivially_drop]
197pub struct Arg(pub Option<String>, pub LocExpr);197pub struct ArgsDesc {
198
199#[cfg_attr(feature = "serialize", derive(Serialize))]198	pub unnamed: Vec<LocExpr>,
200#[cfg_attr(feature = "deserialize", derive(Deserialize))]199	pub named: Vec<(IStr, LocExpr)>,
201#[derive(Debug, PartialEq, Trace)]200}
202#[trivially_drop]
203pub struct ArgsDesc(pub Vec<Arg>);
204
205impl Deref for ArgsDesc {201impl ArgsDesc {
206	type Target = Vec<Arg>;
207	fn deref(&self) -> &Self::Target {202	pub fn new(unnamed: Vec<LocExpr>, named: Vec<(IStr, LocExpr)>) -> Self {
208		&self.0203		Self { unnamed, named }
209	}204	}
210}205}
211206

7};7};
8mod expr;8mod expr;
9pub use expr::*;9pub use expr::*;
10pub use jrsonnet_interner::IStr;
10pub use peg;11pub use peg;
1112
12pub struct ParserSettings {13pub struct ParserSettings {
70			}71			}
71			/ { expr::ParamsDesc(Rc::new(Vec::new())) }72			/ { expr::ParamsDesc(Rc::new(Vec::new())) }
7273
73		pub rule arg(s: &ParserSettings) -> expr::Arg74		pub rule arg(s: &ParserSettings) -> (Option<IStr>, LocExpr)
74			= name:$(id()) _ "=" _ expr:expr(s) {expr::Arg(Some(name.into()), expr)}75			= quiet! { name:(s:$(id()) _ "=" _ {s})? expr:expr(s) {(name.map(Into::into), expr)} }
75			/ expr:expr(s) {expr::Arg(None, expr)}76			/ expected!("<argument>")
77
76		pub rule args(s: &ParserSettings) -> expr::ArgsDesc78		pub rule args(s: &ParserSettings) -> expr::ArgsDesc
77			= args:arg(s) ** comma() comma()? {79			= args:arg(s)**comma() comma()? {?
80				let unnamed_count = args.iter().take_while(|(n, _)| n.is_none()).count();
81				let mut unnamed = Vec::with_capacity(unnamed_count);
82				let mut named = Vec::with_capacity(args.len() - unnamed_count);
78				let mut named_started = false;83				let mut named_started = false;
79				for arg in &args {84				for (name, value) in args {
80					named_started = named_started || arg.0.is_some();85					if let Some(name) = name {
86						named_started = true;
87						named.push((name, value));
88					} else {
81					assert_eq!(named_started, arg.0.is_some(), "named args should be used after all positionals");89						if named_started {
90							return Err("<named argument>")
91						}
92						unnamed.push(value);
93					}
82				}94				}
83				expr::ArgsDesc(args)95				Ok(expr::ArgsDesc::new(unnamed, named))
84			}96			}
85			/ { expr::ArgsDesc(Vec::new()) }
8697
87		pub rule bind(s: &ParserSettings) -> expr::BindSpec98		pub rule bind(s: &ParserSettings) -> expr::BindSpec
88			= name:$(id()) _ "=" _ expr:expr(s) {expr::BindSpec{name:name.into(), params: None, value: expr}}99			= name:$(id()) _ "=" _ expr:expr(s) {expr::BindSpec{name:name.into(), params: None, value: expr}}
493			el!(ArrComp(504			el!(ArrComp(
494				el!(Apply(505				el!(Apply(
495					el!(Index(el!(Var("std".into())), el!(Str("deepJoin".into())))),506					el!(Index(el!(Var("std".into())), el!(Str("deepJoin".into())))),
496					ArgsDesc(vec![Arg(None, el!(Var("x".into())))]),507					ArgsDesc::new(vec![el!(Var("x".into()))], vec![]),
497					false,508					false,
498				)),509				)),
499				vec![CompSpec::ForSpec(ForSpecData(510				vec![CompSpec::ForSpec(ForSpecData(