git.delta.rocks / jrsonnet / refs/commits / 795a53dd5dd7

difftreelog

refactor drop ArgsLike abstraction

pltounypYaroslav Bolyukin2026-03-22parent: #cf6d90f.patch.diff
in: master

17 files changed

modifiedbindings/jsonnet/src/lib.rsdiffbeforeafterboth
--- a/bindings/jsonnet/src/lib.rs
+++ b/bindings/jsonnet/src/lib.rs
@@ -22,11 +22,11 @@
 
 use jrsonnet_evaluator::{
 	apply_tla, bail,
-	function::TlaArg,
 	gc::WithCapacityExt as _,
 	manifest::{JsonFormat, ManifestFormat, ToStringFormat},
 	rustc_hash::FxHashMap,
 	stack::set_stack_depth_limit,
+	tla::TlaArg,
 	trace::{CompactFormat, PathResolver, TraceFormat},
 	AsPathLike, FileImportResolver, IStr, ImportResolver, Result, State, Val,
 };
@@ -40,6 +40,7 @@
 pub extern "C" fn _start() {}
 
 /// Return the version string of the Jsonnet interpreter.
+///
 /// Conforms to [semantic versioning](http://semver.org/).
 /// If this does not match `LIB_JSONNET_VERSION`
 /// then there is a mismatch between header and compiled library.
modifiedbindings/jsonnet/src/vars_tlas.rsdiffbeforeafterboth
--- a/bindings/jsonnet/src/vars_tlas.rs
+++ b/bindings/jsonnet/src/vars_tlas.rs
@@ -2,7 +2,8 @@
 
 use std::{ffi::CStr, os::raw::c_char};
 
-use jrsonnet_evaluator::{function::TlaArg, IStr};
+use jrsonnet_evaluator::tla::TlaArg;
+use jrsonnet_evaluator::IStr;
 
 use crate::VM;
modifiedcrates/jrsonnet-cli/src/stdlib.rsdiffbeforeafterboth
--- a/crates/jrsonnet-cli/src/stdlib.rs
+++ b/crates/jrsonnet-cli/src/stdlib.rs
@@ -1,7 +1,8 @@
 use std::str::FromStr;
 
 use clap::Parser;
-use jrsonnet_evaluator::{function::TlaArg, trace::PathResolver, Result};
+use jrsonnet_evaluator::tla::TlaArg;
+use jrsonnet_evaluator::{trace::PathResolver, Result};
 use jrsonnet_stdlib::ContextInitializer;
 
 #[derive(Clone)]
modifiedcrates/jrsonnet-cli/src/tla.rsdiffbeforeafterboth
--- a/crates/jrsonnet-cli/src/tla.rs
+++ b/crates/jrsonnet-cli/src/tla.rs
@@ -1,7 +1,6 @@
 use clap::Parser;
-use jrsonnet_evaluator::{
-	error::Result, function::TlaArg, gc::WithCapacityExt as _, rustc_hash::FxHashMap, IStr,
-};
+use jrsonnet_evaluator::tla::TlaArg;
+use jrsonnet_evaluator::{error::Result, gc::WithCapacityExt as _, rustc_hash::FxHashMap, IStr};
 
 use crate::{ExtFile, ExtStr};
modifiedcrates/jrsonnet-evaluator/src/arr/mod.rsdiffbeforeafterboth
--- a/crates/jrsonnet-evaluator/src/arr/mod.rs
+++ b/crates/jrsonnet-evaluator/src/arr/mod.rs
@@ -9,7 +9,7 @@
 use jrsonnet_interner::IBytes;
 use jrsonnet_parser::{Expr, Spanned};
 
-use crate::{typed::NativeFn, Context, Result, Thunk, Val};
+use crate::{function::NativeFn, Context, Result, Thunk, Val};
 
 mod spec;
 pub use spec::{ArrayLike, *};
modifiedcrates/jrsonnet-evaluator/src/arr/spec.rsdiffbeforeafterboth
--- a/crates/jrsonnet-evaluator/src/arr/spec.rs
+++ b/crates/jrsonnet-evaluator/src/arr/spec.rs
@@ -6,8 +6,7 @@
 use jrsonnet_parser::{Expr, Spanned};
 
 use super::ArrValue;
-use crate::typed::NativeFn;
-use crate::val::NumValue;
+use crate::function::NativeFn;
 use crate::{
 	error::ErrorKind::InfiniteRecursionDetected, evaluate, typed::Typed, val::ThunkValue, Context,
 	Error, ObjValue, Result, Thunk, Val,
deletedcrates/jrsonnet-evaluator/src/function/arglike.rsdiffbeforeafterboth
--- a/crates/jrsonnet-evaluator/src/function/arglike.rs
+++ /dev/null
@@ -1,197 +0,0 @@
-use std::collections::HashMap;
-use std::rc::Rc;
-
-use jrsonnet_gcmodule::Trace;
-use jrsonnet_interner::IStr;
-use jrsonnet_parser::{ArgsDesc, Expr, SourceFifo, SourcePath, Spanned};
-
-use crate::{evaluate, typed::Typed, with_state, Context, Result, Thunk, Val};
-
-pub trait ArgLike {
-	fn evaluate_arg(&self, ctx: Context, tailstrict: bool) -> Result<Thunk<Val>>;
-}
-
-impl ArgLike for &Rc<Spanned<Expr>> {
-	fn evaluate_arg(&self, ctx: Context, tailstrict: bool) -> Result<Thunk<Val>> {
-		Ok(if tailstrict {
-			Thunk::evaluated(evaluate(ctx, self)?)
-		} else {
-			let expr = (*self).clone();
-			Thunk!(move || evaluate(ctx, &expr))
-		})
-	}
-}
-
-impl<T> ArgLike for T
-where
-	T: Typed + Clone,
-{
-	fn evaluate_arg(&self, _ctx: Context, tailstrict: bool) -> Result<Thunk<Val>> {
-		if T::provides_lazy() && !tailstrict {
-			return Ok(T::into_lazy_untyped(self.clone()));
-		}
-		let val = T::into_untyped(self.clone())?;
-		Ok(Thunk::evaluated(val))
-	}
-}
-
-#[derive(Clone, Trace)]
-pub enum TlaArg {
-	String(IStr),
-	Val(Val),
-	Lazy(Thunk<Val>),
-	Import(String),
-	ImportStr(String),
-	InlineCode(String),
-}
-impl TlaArg {
-	pub fn evaluate_tailstrict(&self) -> Result<Val> {
-		match self {
-			Self::String(s) => Ok(Val::string(s.clone())),
-			Self::Val(val) => Ok(val.clone()),
-			Self::Lazy(lazy) => Ok(lazy.evaluate()?),
-			Self::Import(p) => with_state(|s| {
-				let resolved = s.resolve_from_default(&p.as_str())?;
-				s.import_resolved(resolved)
-			}),
-			Self::ImportStr(p) => with_state(|s| {
-				let resolved = s.resolve_from_default(&p.as_str())?;
-				s.import_resolved_str(resolved).map(Val::string)
-			}),
-			Self::InlineCode(p) => with_state(|s| {
-				let resolved =
-					SourcePath::new(SourceFifo("<inline code>".to_owned(), p.as_bytes().into()));
-				s.import_resolved(resolved)
-			}),
-		}
-	}
-	pub fn evaluate(&self) -> Result<Thunk<Val>> {
-		match self {
-			Self::String(s) => Ok(Thunk::evaluated(Val::string(s.clone()))),
-			Self::Val(val) => Ok(Thunk::evaluated(val.clone())),
-			Self::Lazy(lazy) => Ok(lazy.clone()),
-			Self::Import(p) => with_state(|s| {
-				let resolved = s.resolve_from_default(&p.as_str())?;
-				Ok(Thunk!(move || s.import_resolved(resolved)))
-			}),
-			Self::ImportStr(p) => with_state(|s| {
-				let resolved = s.resolve_from_default(&p.as_str())?;
-				Ok(Thunk!(move || s
-					.import_resolved_str(resolved)
-					.map(Val::string)))
-			}),
-			Self::InlineCode(p) => with_state(|s| {
-				let resolved =
-					SourcePath::new(SourceFifo("<inline code>".to_owned(), p.as_bytes().into()));
-				Ok(Thunk!(move || s.import_resolved(resolved)))
-			}),
-		}
-	}
-}
-
-pub trait ArgsLike {
-	fn unnamed_len(&self) -> usize;
-	fn unnamed_iter(
-		&self,
-		ctx: Context,
-		tailstrict: bool,
-		handler: &mut dyn FnMut(usize, Thunk<Val>) -> Result<()>,
-	) -> Result<()>;
-	fn named_iter(
-		&self,
-		ctx: Context,
-		tailstrict: bool,
-		handler: &mut dyn FnMut(&IStr, Thunk<Val>) -> Result<()>,
-	) -> Result<()>;
-	fn named_names(&self, handler: &mut dyn FnMut(&IStr));
-	fn is_empty(&self) -> bool;
-}
-
-impl ArgsLike for Vec<Val> {
-	fn unnamed_len(&self) -> usize {
-		self.len()
-	}
-	fn unnamed_iter(
-		&self,
-		_ctx: Context,
-		_tailstrict: bool,
-		handler: &mut dyn FnMut(usize, Thunk<Val>) -> Result<()>,
-	) -> Result<()> {
-		for (idx, el) in self.iter().enumerate() {
-			handler(idx, Thunk::evaluated(el.clone()))?;
-		}
-		Ok(())
-	}
-	fn named_iter(
-		&self,
-		_ctx: Context,
-		_tailstrict: bool,
-		_handler: &mut dyn FnMut(&IStr, Thunk<Val>) -> Result<()>,
-	) -> Result<()> {
-		Ok(())
-	}
-	fn named_names(&self, _handler: &mut dyn FnMut(&IStr)) {}
-	fn is_empty(&self) -> bool {
-		self.is_empty()
-	}
-}
-
-impl ArgsLike for ArgsDesc {
-	fn unnamed_len(&self) -> usize {
-		self.unnamed.len()
-	}
-
-	fn unnamed_iter(
-		&self,
-		ctx: Context,
-		tailstrict: bool,
-		handler: &mut dyn FnMut(usize, Thunk<Val>) -> Result<()>,
-	) -> Result<()> {
-		for (id, arg) in self.unnamed.iter().enumerate() {
-			handler(
-				id,
-				if tailstrict {
-					Thunk::evaluated(evaluate(ctx.clone(), arg)?)
-				} else {
-					let ctx = ctx.clone();
-					let arg = arg.clone();
-
-					Thunk!(move || evaluate(ctx, &arg))
-				},
-			)?;
-		}
-		Ok(())
-	}
-
-	fn named_iter(
-		&self,
-		ctx: Context,
-		tailstrict: bool,
-		handler: &mut dyn FnMut(&IStr, Thunk<Val>) -> Result<()>,
-	) -> Result<()> {
-		for (name, arg) in &self.named {
-			handler(
-				name,
-				if tailstrict {
-					Thunk::evaluated(evaluate(ctx.clone(), arg)?)
-				} else {
-					let ctx = ctx.clone();
-					let arg = arg.clone();
-
-					Thunk!(move || evaluate(ctx, &arg))
-				},
-			)?;
-		}
-		Ok(())
-	}
-
-	fn named_names(&self, handler: &mut dyn FnMut(&IStr)) {
-		for (name, _) in &self.named {
-			handler(name);
-		}
-	}
-
-	fn is_empty(&self) -> bool {
-		self.unnamed.is_empty() && self.named.is_empty()
-	}
-}
modifiedcrates/jrsonnet-evaluator/src/function/mod.rsdiffbeforeafterboth
--- a/crates/jrsonnet-evaluator/src/function/mod.rs
+++ b/crates/jrsonnet-evaluator/src/function/mod.rs
@@ -1,11 +1,10 @@
 use std::{fmt::Debug, rc::Rc};
 
-pub use arglike::{ArgLike, ArgsLike, TlaArg};
 use educe::Educe;
 use jrsonnet_gcmodule::{Cc, Trace};
 use jrsonnet_interner::IStr;
 pub use jrsonnet_macros::builtin;
-use jrsonnet_parser::{Destruct, Expr, ExprParams, Span, Spanned};
+use jrsonnet_parser::{ArgsDesc, Destruct, Expr, ExprParams, Span, Spanned};
 
 use self::{
 	builtin::{Builtin, StaticBuiltin},
@@ -17,12 +16,12 @@
 	Result, Thunk, Val,
 };
 
-pub mod arglike;
 pub mod builtin;
-pub mod native;
-pub mod parse;
+mod native;
+mod parse;
 mod prepared;
 
+pub use native::NativeFn;
 pub use prepared::PreparedFuncVal;
 
 pub use jrsonnet_parser::function::*;
@@ -81,10 +80,10 @@
 	}
 
 	/// Create context, with which body code will run
-	pub fn call_body_context(
+	pub(crate) fn call_body_context(
 		&self,
 		call_ctx: Context,
-		args: &dyn ArgsLike,
+		args: &ArgsDesc,
 		tailstrict: bool,
 	) -> Result<Context> {
 		parse_function_call(call_ctx, self.ctx.clone(), &self.params, args, tailstrict)
@@ -170,7 +169,7 @@
 		&self,
 		call_ctx: Context,
 		loc: CallLocation<'_>,
-		args: &dyn ArgsLike,
+		args: &ArgsDesc,
 		tailstrict: bool,
 	) -> Result<Val> {
 		match self {
@@ -179,7 +178,7 @@
 				evaluate(body_ctx, &func.body)
 			}
 			Self::Thunk(thunk) => {
-				if !args.is_empty() {
+				if !args.named.is_empty() || !args.unnamed.is_empty() {
 					bail!(TooManyArgsFunctionHas(0, FunctionSignature::empty()))
 				}
 				thunk.evaluate()
modifiedcrates/jrsonnet-evaluator/src/function/native.rsdiffbeforeafterboth
--- a/crates/jrsonnet-evaluator/src/function/native.rs
+++ b/crates/jrsonnet-evaluator/src/function/native.rs
@@ -1,2 +1,68 @@
+use std::marker::PhantomData;
+
+use jrsonnet_gcmodule::Trace;
+
 use super::PreparedFuncVal;
-use crate::{typed::Typed, CallLocation, Result, Thunk};
+use crate::{bail, function::FuncVal, typed::Typed, CallLocation, Result, Val};
+use jrsonnet_types::{ComplexValType, ValType};
+
+#[derive(Debug, Trace, Clone)]
+pub struct NativeFn<D: 'static>(pub(crate) PreparedFuncVal, PhantomData<D>);
+macro_rules! impl_native_desc {
+	($i:expr; $($gen:ident)*) => {
+		impl<$($gen,)* O> NativeFn<($($gen,)* O,)>
+		where
+			$($gen: Typed,)*
+			O: Typed,
+		{
+			#[allow(non_snake_case, clippy::too_many_arguments)]
+			pub fn call(
+				&self,
+				$($gen: $gen,)*
+			) -> Result<O> {
+				let val = self.0.call(
+					CallLocation::native(),
+					&[$(Typed::into_lazy_untyped($gen),)*],
+					&[],
+				)?;
+				O::from_untyped(val)
+			}
+		}
+		impl<$($gen,)* O> Typed for NativeFn<($($gen,)* O,)> {
+			const TYPE: &'static ComplexValType = &ComplexValType::Simple(ValType::Func);
+
+			fn into_untyped(_typed: Self) -> Result<Val> {
+				bail!("can only convert functions from jsonnet to native")
+			}
+
+			fn from_untyped(untyped: Val) -> Result<Self> {
+				let func = FuncVal::from_untyped(untyped)?;
+				Ok(Self(
+					PreparedFuncVal::new(func, $i, &[])?,
+					PhantomData,
+				))
+			}
+		}
+	};
+	($i:expr; $($cur:ident)* @ $c:ident $($rest:ident)*) => {
+		impl_native_desc!($i; $($cur)*);
+		impl_native_desc!($i + 1; $($cur)* $c @ $($rest)*);
+	};
+	($i:expr; $($cur:ident)* @) => {
+		impl_native_desc!($i; $($cur)*);
+	}
+}
+
+impl_native_desc! {
+	0; @ A B C D E F G H I J K L
+}
+
+mod native_macro {
+	#[macro_export]
+	macro_rules! NativeFn {
+		(($($t:ty),* $(,)?) -> $res:ty) => {
+			NativeFn<($($t,)* $res)>
+		}
+	}
+}
+pub use crate::NativeFn;
modifiedcrates/jrsonnet-evaluator/src/function/parse.rsdiffbeforeafterboth
before · crates/jrsonnet-evaluator/src/function/parse.rs
1use jrsonnet_parser::{2	function::{FunctionSignature, ParamName},3	ExprParams,4};5use rustc_hash::FxHashMap;67use super::arglike::ArgsLike;8use crate::{9	bail,10	destructure::destruct,11	error::{ErrorKind::*, Result},12	evaluate_named_param,13	gc::WithCapacityExt as _,14	Context, Pending, Thunk, Val,15};1617/// Creates correct [context](Context) for function body evaluation returning error on invalid call.18///19/// ## Parameters20/// * `ctx`: used for passed argument expressions' execution and for body execution (if `body_ctx` is not set)21/// * `body_ctx`: used for default parameter values' execution and for body execution (if set)22/// * `params`: function parameters' definition23/// * `args`: passed function arguments24/// * `tailstrict`: if set to `true` function arguments are eagerly executed, otherwise - lazily25pub fn parse_function_call(26	ctx: Context,27	body_ctx: Context,28	params: &ExprParams,29	args: &dyn ArgsLike,30	tailstrict: bool,31) -> Result<Context> {32	let mut passed_args = FxHashMap::with_capacity(params.binds_len());33	if args.unnamed_len() > params.signature.len() {34		bail!(TooManyArgsFunctionHas(35			params.signature.len(),36			params.signature.clone(),37		))38	}3940	let mut filled_named = 0;41	let mut filled_positionals = 0;4243	args.unnamed_iter(ctx.clone(), tailstrict, &mut |id, arg| {44		destruct(45			&params.exprs[id].destruct,46			arg,47			Pending::new_filled(ctx.clone()),48			&mut passed_args,49		)?;50		filled_positionals += 1;51		Ok(())52	})?;5354	args.named_iter(ctx, tailstrict, &mut |name, value| {55		// FIXME: O(n) for arg existence check56		if !params.exprs.iter().any(|p| &p.destruct.name() == name) {57			bail!(UnknownFunctionParameter(name.clone()));58		}59		if passed_args.insert(name.clone(), value).is_some() {60			bail!(BindingParameterASecondTime(name.clone()));61		}62		filled_named += 1;63		Ok(())64	})?;6566	if filled_named + filled_positionals < params.len() {67		// Some args are unset, but maybe we have defaults for them68		// Default values should be created in newly created context69		let fctx = Context::new_future();70		let mut defaults =71			FxHashMap::with_capacity(params.binds_len() - filled_named - filled_positionals);7273		for (idx, into, default) in params74			.exprs75			.iter()76			.enumerate()77			.filter_map(|(i, p)| Some((i, &p.destruct, p.default.as_ref()?)))78		{79			if let ParamName::Named(name) = into.name() {80				if passed_args.contains_key(&name) {81					continue;82				}83			} else if idx < filled_positionals {84				continue;85			}8687			destruct(88				into,89				{90					let ctx = fctx.clone();91					let name = into.name();92					let value = default.clone();93					Thunk!(move || evaluate_named_param(ctx.unwrap(), &value, name))94				},95				fctx.clone(),96				&mut defaults,97			)?;98			if into.name().is_named() {99				filled_named += 1;100			} else {101				filled_positionals += 1;102			}103		}104105		// Some args still weren't filled106		if filled_named + filled_positionals != params.len() {107			for param in params.exprs.iter().skip(args.unnamed_len()) {108				let mut found = false;109				args.named_names(&mut |name| {110					if &param.destruct.name() == name {111						found = true;112					}113				});114				if !found {115					bail!(FunctionParameterNotBoundInCall(116						param.destruct.name(),117						params.signature.clone()118					));119				}120			}121			unreachable!();122		}123124		Ok(body_ctx125			.extend_bindings(passed_args)126			.extend_bindings(defaults)127			.into_future(fctx))128	} else {129		let body_ctx = body_ctx.extend_bindings(passed_args);130		Ok(body_ctx)131	}132}133134/// You shouldn't probally use this function, use `jrsonnet_macros::builtin` instead135///136/// ## Parameters137/// * `ctx`: used for passed argument expressions' execution and for body execution (if `body_ctx` is not set)138/// * `params`: function parameters' definition139/// * `args`: passed function arguments140/// * `tailstrict`: if set to `true` function arguments are eagerly executed, otherwise - lazily141pub fn parse_builtin_call(142	ctx: Context,143	params: FunctionSignature,144	args: &dyn ArgsLike,145	tailstrict: bool,146) -> Result<Vec<Option<Thunk<Val>>>> {147	let mut passed_args: Vec<Option<Thunk<Val>>> = vec![None; params.len()];148	if args.unnamed_len() > params.len() {149		bail!(TooManyArgsFunctionHas(params.len(), params,))150	}151152	let mut filled_args = 0;153154	args.unnamed_iter(ctx.clone(), tailstrict, &mut |id, arg| {155		passed_args[id] = Some(arg);156		filled_args += 1;157		Ok(())158	})?;159160	args.named_iter(ctx, tailstrict, &mut |name, arg| {161		// FIXME: O(n) for arg existence check162		let id = params163			.iter()164			.position(|p| p.name() == name)165			.ok_or_else(|| UnknownFunctionParameter(name.clone()))?;166		if passed_args[id].replace(arg).is_some() {167			bail!(BindingParameterASecondTime(name.clone()));168		}169		filled_args += 1;170		Ok(())171	})?;172173	if filled_args < params.len() {174		for (id, _) in params.iter().enumerate().filter(|(_, p)| p.has_default()) {175			if passed_args[id].is_some() {176				continue;177			}178			filled_args += 1;179		}180181		// Some args still wasn't filled182		if filled_args != params.len() {183			for param in params.iter().skip(args.unnamed_len()) {184				let mut found = false;185				args.named_names(&mut |name| {186					if param.name() == name {187						found = true;188					}189				});190				if !found {191					bail!(FunctionParameterNotBoundInCall(192						param.name().clone(),193						params,194					));195				}196			}197			unreachable!();198		}199	}200	Ok(passed_args)201}202203/// Creates Context, which has all argument default values applied204/// and with unbound values causing error to be returned205pub fn parse_default_function_call(body_ctx: Context, params: &ExprParams) -> Result<Context> {206	let fctx = Context::new_future();207208	let mut bindings = FxHashMap::with_capacity(params.binds_len());209210	for param in params.exprs.iter() {211		if let Some(v) = &param.default {212			destruct(213				&param.destruct.clone(),214				{215					let ctx = fctx.clone();216					let name = param.destruct.name();217					let value = v.clone();218					Thunk!(move || evaluate_named_param(ctx.unwrap(), &value, name))219				},220				fctx.clone(),221				&mut bindings,222			)?;223		} else {224			destruct(225				&param.destruct,226				{227					let param_name = param.destruct.name();228					let params = params.clone();229					Thunk!(move || Err(FunctionParameterNotBoundInCall(230						param_name,231						params.signature232					)233					.into()))234				},235				fctx.clone(),236				&mut bindings,237			)?;238		}239	}240241	Ok(body_ctx.extend_bindings(bindings).into_future(fctx))242}
after · crates/jrsonnet-evaluator/src/function/parse.rs
1use std::rc::Rc;23use jrsonnet_parser::{4	function::{FunctionSignature, ParamName},5	ArgsDesc, Expr, ExprParams, Spanned,6};7use rustc_hash::FxHashMap;89use crate::{10	bail,11	destructure::destruct,12	error::{ErrorKind::*, Result},13	evaluate, evaluate_named_param,14	gc::WithCapacityExt as _,15	Context, Pending, Thunk, Val,16};1718fn eval_arg(ctx: Context, arg: &Rc<Spanned<Expr>>, tailstrict: bool) -> Result<Thunk<Val>> {19	if tailstrict {20		Ok(Thunk::evaluated(evaluate(ctx, arg)?))21	} else {22		let arg = arg.clone();23		Ok(Thunk!(move || evaluate(ctx, &arg)))24	}25}2627/// Creates correct [context](Context) for function body evaluation returning error on invalid call.28///29/// ## Parameters30/// * `ctx`: used for passed argument expressions' execution and for body execution (if `body_ctx` is not set)31/// * `body_ctx`: used for default parameter values' execution and for body execution (if set)32/// * `params`: function parameters' definition33/// * `args`: passed function arguments34/// * `tailstrict`: if set to `true` function arguments are eagerly executed, otherwise - lazily35pub(crate) fn parse_function_call(36	ctx: Context,37	body_ctx: Context,38	params: &ExprParams,39	args: &ArgsDesc,40	tailstrict: bool,41) -> Result<Context> {42	let mut passed_args = FxHashMap::with_capacity(params.binds_len());43	if args.unnamed.len() > params.signature.len() {44		bail!(TooManyArgsFunctionHas(45			params.signature.len(),46			params.signature.clone(),47		))48	}4950	let mut filled_named = 0;51	let mut filled_positionals = 0;5253	for (id, arg) in args.unnamed.iter().enumerate() {54		destruct(55			&params.exprs[id].destruct,56			eval_arg(ctx.clone(), arg, tailstrict)?,57			Pending::new_filled(ctx.clone()),58			&mut passed_args,59		)?;60		filled_positionals += 1;61	}6263	for (name, value) in &args.named {64		// FIXME: O(n) for arg existence check65		if !params.exprs.iter().any(|p| &p.destruct.name() == name) {66			bail!(UnknownFunctionParameter(name.clone()));67		}68		if passed_args69			.insert(name.clone(), eval_arg(ctx.clone(), value, tailstrict)?)70			.is_some()71		{72			bail!(BindingParameterASecondTime(name.clone()));73		}74		filled_named += 1;75	}7677	if filled_named + filled_positionals < params.len() {78		// Some args are unset, but maybe we have defaults for them79		// Default values should be created in newly created context80		let fctx = Context::new_future();81		let mut defaults =82			FxHashMap::with_capacity(params.binds_len() - filled_named - filled_positionals);8384		for (idx, into, default) in params85			.exprs86			.iter()87			.enumerate()88			.filter_map(|(i, p)| Some((i, &p.destruct, p.default.as_ref()?)))89		{90			if let ParamName::Named(name) = into.name() {91				if passed_args.contains_key(&name) {92					continue;93				}94			} else if idx < filled_positionals {95				continue;96			}9798			destruct(99				into,100				{101					let ctx = fctx.clone();102					let name = into.name();103					let value = default.clone();104					Thunk!(move || evaluate_named_param(ctx.unwrap(), &value, name))105				},106				fctx.clone(),107				&mut defaults,108			)?;109			if into.name().is_named() {110				filled_named += 1;111			} else {112				filled_positionals += 1;113			}114		}115116		// Some args still weren't filled117		if filled_named + filled_positionals != params.len() {118			for param in params.exprs.iter().skip(args.unnamed.len()) {119				let mut found = false;120				for (name, _) in &args.named {121					if &param.destruct.name() == name {122						found = true;123					}124				}125				if !found {126					bail!(FunctionParameterNotBoundInCall(127						param.destruct.name(),128						params.signature.clone()129					));130				}131			}132			unreachable!();133		}134135		Ok(body_ctx136			.extend_bindings(passed_args)137			.extend_bindings(defaults)138			.into_future(fctx))139	} else {140		let body_ctx = body_ctx.extend_bindings(passed_args);141		Ok(body_ctx)142	}143}144145/// You shouldn't probally use this function, use `jrsonnet_macros::builtin` instead146///147/// ## Parameters148/// * `ctx`: used for passed argument expressions' execution and for body execution (if `body_ctx` is not set)149/// * `params`: function parameters' definition150/// * `args`: passed function arguments151/// * `tailstrict`: if set to `true` function arguments are eagerly executed, otherwise - lazily152pub fn parse_builtin_call(153	ctx: Context,154	params: FunctionSignature,155	args: &ArgsDesc,156	tailstrict: bool,157) -> Result<Vec<Option<Thunk<Val>>>> {158	let mut passed_args: Vec<Option<Thunk<Val>>> = vec![None; params.len()];159	if args.unnamed.len() > params.len() {160		bail!(TooManyArgsFunctionHas(params.len(), params,))161	}162163	let mut filled_args = 0;164165	for (id, arg) in args.unnamed.iter().enumerate() {166		passed_args[id] = Some(eval_arg(ctx.clone(), arg, tailstrict)?);167		filled_args += 1;168	}169170	for (name, arg) in &args.named {171		// FIXME: O(n) for arg existence check172		let id = params173			.iter()174			.position(|p| p.name() == name)175			.ok_or_else(|| UnknownFunctionParameter(name.clone()))?;176		if passed_args[id]177			.replace(eval_arg(ctx.clone(), arg, tailstrict)?)178			.is_some()179		{180			bail!(BindingParameterASecondTime(name.clone()));181		}182		filled_args += 1;183	}184185	if filled_args < params.len() {186		for (id, _) in params.iter().enumerate().filter(|(_, p)| p.has_default()) {187			if passed_args[id].is_some() {188				continue;189			}190			filled_args += 1;191		}192193		// Some args still wasn't filled194		if filled_args != params.len() {195			for param in params.iter().skip(args.unnamed.len()) {196				let mut found = false;197				for (name, _) in &args.named {198					if param.name() == name {199						found = true;200					}201				}202				if !found {203					bail!(FunctionParameterNotBoundInCall(204						param.name().clone(),205						params,206					));207				}208			}209			unreachable!();210		}211	}212	Ok(passed_args)213}214215/// Creates Context, which has all argument default values applied216/// and with unbound values causing error to be returned217pub fn parse_default_function_call(body_ctx: Context, params: &ExprParams) -> Result<Context> {218	let fctx = Context::new_future();219220	let mut bindings = FxHashMap::with_capacity(params.binds_len());221222	for param in params.exprs.iter() {223		if let Some(v) = &param.default {224			destruct(225				&param.destruct.clone(),226				{227					let ctx = fctx.clone();228					let name = param.destruct.name();229					let value = v.clone();230					Thunk!(move || evaluate_named_param(ctx.unwrap(), &value, name))231				},232				fctx.clone(),233				&mut bindings,234			)?;235		} else {236			destruct(237				&param.destruct,238				{239					let param_name = param.destruct.name();240					let params = params.clone();241					Thunk!(move || Err(FunctionParameterNotBoundInCall(242						param_name,243						params.signature244					)245					.into()))246				},247				fctx.clone(),248				&mut bindings,249			)?;250		}251	}252253	Ok(body_ctx.extend_bindings(bindings).into_future(fctx))254}
modifiedcrates/jrsonnet-evaluator/src/lib.rsdiffbeforeafterboth
--- a/crates/jrsonnet-evaluator/src/lib.rs
+++ b/crates/jrsonnet-evaluator/src/lib.rs
@@ -19,7 +19,7 @@
 mod obj;
 pub mod stack;
 pub mod stdlib;
-mod tla;
+pub mod tla;
 pub mod trace;
 pub mod typed;
 pub mod val;
modifiedcrates/jrsonnet-evaluator/src/tla.rsdiffbeforeafterboth
--- a/crates/jrsonnet-evaluator/src/tla.rs
+++ b/crates/jrsonnet-evaluator/src/tla.rs
@@ -1,12 +1,68 @@
 use std::{collections::HashMap, hash::BuildHasher};
 
+use jrsonnet_gcmodule::Trace;
 use jrsonnet_interner::IStr;
+use jrsonnet_parser::{SourceFifo, SourcePath};
 
 use crate::{
-	function::{CallLocation, PreparedFuncVal, TlaArg},
-	in_description_frame, Result, Val,
+	function::{CallLocation, PreparedFuncVal},
+	in_description_frame, with_state, Result, Thunk, Val,
 };
 
+#[derive(Clone, Trace)]
+pub enum TlaArg {
+	String(IStr),
+	Val(Val),
+	Lazy(Thunk<Val>),
+	Import(String),
+	ImportStr(String),
+	InlineCode(String),
+}
+impl TlaArg {
+	pub fn evaluate_tailstrict(&self) -> Result<Val> {
+		match self {
+			Self::String(s) => Ok(Val::string(s.clone())),
+			Self::Val(val) => Ok(val.clone()),
+			Self::Lazy(lazy) => Ok(lazy.evaluate()?),
+			Self::Import(p) => with_state(|s| {
+				let resolved = s.resolve_from_default(&p.as_str())?;
+				s.import_resolved(resolved)
+			}),
+			Self::ImportStr(p) => with_state(|s| {
+				let resolved = s.resolve_from_default(&p.as_str())?;
+				s.import_resolved_str(resolved).map(Val::string)
+			}),
+			Self::InlineCode(p) => with_state(|s| {
+				let resolved =
+					SourcePath::new(SourceFifo("<inline code>".to_owned(), p.as_bytes().into()));
+				s.import_resolved(resolved)
+			}),
+		}
+	}
+	pub fn evaluate(&self) -> Result<Thunk<Val>> {
+		match self {
+			Self::String(s) => Ok(Thunk::evaluated(Val::string(s.clone()))),
+			Self::Val(val) => Ok(Thunk::evaluated(val.clone())),
+			Self::Lazy(lazy) => Ok(lazy.clone()),
+			Self::Import(p) => with_state(|s| {
+				let resolved = s.resolve_from_default(&p.as_str())?;
+				Ok(Thunk!(move || s.import_resolved(resolved)))
+			}),
+			Self::ImportStr(p) => with_state(|s| {
+				let resolved = s.resolve_from_default(&p.as_str())?;
+				Ok(Thunk!(move || s
+					.import_resolved_str(resolved)
+					.map(Val::string)))
+			}),
+			Self::InlineCode(p) => with_state(|s| {
+				let resolved =
+					SourcePath::new(SourceFifo("<inline code>".to_owned(), p.as_bytes().into()));
+				Ok(Thunk!(move || s.import_resolved(resolved)))
+			}),
+		}
+	}
+}
+
 pub fn apply_tla<H: BuildHasher>(args: &HashMap<IStr, TlaArg, H>, val: Val) -> Result<Val> {
 	Ok(if let Val::Func(func) = val {
 		in_description_frame(
modifiedcrates/jrsonnet-evaluator/src/typed/conversions.rsdiffbeforeafterboth
--- a/crates/jrsonnet-evaluator/src/typed/conversions.rs
+++ b/crates/jrsonnet-evaluator/src/typed/conversions.rs
@@ -8,7 +8,7 @@
 use crate::{
 	arr::{ArrValue, BytesArray},
 	bail,
-	function::{CallLocation, FuncDesc, FuncVal, PreparedFuncVal},
+	function::{FuncDesc, FuncVal},
 	typed::CheckType,
 	val::{IndexableVal, NumValue, StrValue, ThunkMapper},
 	ObjValue, ObjValueBuilder, Result, ResultExt, Thunk, Val,
@@ -671,69 +671,9 @@
 			Ok(None)
 		} else {
 			T::from_untyped(untyped).map(Some)
-		}
-	}
-}
-
-#[derive(Debug, Trace, Clone)]
-pub struct NativeFn<D: 'static>(pub(crate) PreparedFuncVal, PhantomData<D>);
-macro_rules! impl_native_desc {
-	($i:expr; $($gen:ident)*) => {
-		impl<$($gen,)* O> NativeFn<($($gen,)* O,)>
-		where
-			$($gen: Typed,)*
-			O: Typed,
-		{
-			pub fn call(
-				&self,
-				$($gen: $gen,)*
-			) -> Result<O> {
-				let val = self.0.call(
-					CallLocation::native(),
-					&[$(Typed::into_lazy_untyped($gen),)*],
-					&[],
-				)?;
-				O::from_untyped(val)
-			}
-		}
-		impl<$($gen,)* O> Typed for NativeFn<($($gen,)* O,)> {
-			const TYPE: &'static ComplexValType = &ComplexValType::Simple(ValType::Func);
-
-			fn into_untyped(_typed: Self) -> Result<Val> {
-				bail!("can only convert functions from jsonnet to native")
-			}
-
-			fn from_untyped(untyped: Val) -> Result<Self> {
-				let func = FuncVal::from_untyped(untyped)?;
-				Ok(Self(
-					PreparedFuncVal::new(func, $i, &[])?,
-					PhantomData,
-				))
-			}
 		}
-	};
-	($i:expr; $($cur:ident)* @ $c:ident $($rest:ident)*) => {
-		impl_native_desc!($i; $($cur)*);
-		impl_native_desc!($i + 1; $($cur)* $c @ $($rest)*);
-	};
-	($i:expr; $($cur:ident)* @) => {
-		impl_native_desc!($i; $($cur)*);
 	}
-}
-
-impl_native_desc! {
-	0; @ A B C D E F G H I J K L
 }
-
-mod native_macro {
-	#[macro_export]
-	macro_rules! NativeFn {
-		(($($t:ty),* $(,)?) -> $res:ty) => {
-			NativeFn<($($t,)* $res)>
-		}
-	}
-}
-pub use crate::NativeFn;
 
 impl Typed for NumValue {
 	const TYPE: &'static ComplexValType = &ComplexValType::Simple(ValType::Num);
modifiedcrates/jrsonnet-macros/src/lib.rsdiffbeforeafterboth
--- a/crates/jrsonnet-macros/src/lib.rs
+++ b/crates/jrsonnet-macros/src/lib.rs
@@ -405,7 +405,7 @@
 		const _: () = {
 			use ::jrsonnet_evaluator::{
 				State, Val,
-				function::{builtin::{Builtin, StaticBuiltin}, FunctionSignature, ParamParse, ParamName, ParamDefault, CallLocation, ArgsLike, parse::parse_builtin_call},
+				function::{builtin::{Builtin, StaticBuiltin}, FunctionSignature, ParamParse, ParamName, ParamDefault, CallLocation},
 				Result, Context, typed::Typed,
 				parser::Span, params, Thunk,
 			};
modifiedcrates/jrsonnet-stdlib/src/arrays.rsdiffbeforeafterboth
--- a/crates/jrsonnet-stdlib/src/arrays.rs
+++ b/crates/jrsonnet-stdlib/src/arrays.rs
@@ -2,9 +2,9 @@
 
 use jrsonnet_evaluator::{
 	bail,
-	function::{builtin, FuncVal},
+	function::{builtin, FuncVal, NativeFn},
 	runtime_error,
-	typed::{BoundedI32, BoundedUsize, Either2, NativeFn, Typed},
+	typed::{BoundedI32, BoundedUsize, Either2, Typed},
 	val::{equals, ArrValue, IndexableVal},
 	Either, IStr, ObjValue, ObjValueBuilder, Result, ResultExt, Thunk, Val,
 };
modifiedcrates/jrsonnet-stdlib/src/lib.rsdiffbeforeafterboth
--- a/crates/jrsonnet-stdlib/src/lib.rs
+++ b/crates/jrsonnet-stdlib/src/lib.rs
@@ -13,7 +13,8 @@
 pub use hash::*;
 use jrsonnet_evaluator::{
 	error::Result,
-	function::{CallLocation, FuncVal, TlaArg},
+	function::{CallLocation, FuncVal},
+	tla::TlaArg,
 	trace::PathResolver,
 	val::NumValue,
 	ContextBuilder, IStr, ObjValue, ObjValueBuilder, Thunk, Val,
modifiedtests/tests/cpp_test_suite.rsdiffbeforeafterboth
--- a/tests/tests/cpp_test_suite.rs
+++ b/tests/tests/cpp_test_suite.rs
@@ -6,10 +6,10 @@
 
 use jrsonnet_evaluator::{
 	FileImportResolver, IStr, ObjValueBuilder, State, Val, apply_tla,
-	function::TlaArg,
 	gc::WithCapacityExt as _,
 	manifest::JsonFormat,
 	rustc_hash::FxHashMap,
+	tla::TlaArg,
 	trace::{CompactFormat, PathResolver, TraceFormat},
 };
 use jrsonnet_stdlib::ContextInitializer;