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

--- a/crates/jrsonnet-evaluator/src/async_import.rs
+++ b/crates/jrsonnet-evaluator/src/async_import.rs
@@ -3,9 +3,9 @@
 
 use jrsonnet_gcmodule::Acyclic;
 use jrsonnet_parser::{
-	ArgsDesc, AssertExpr, AssertStmt, BindSpec, CompSpec, Destruct, Expr, FieldMember, FieldName,
-	ForSpecData, IfElse, IfSpecData, ImportKind, ObjBody, Param, ParamsDesc,
-	ParserSettings, Slice, SliceDesc, Source, SourcePath, Spanned,
+	ArgsDesc, AssertExpr, AssertStmt, BindSpec, CompSpec, Destruct, Expr, ExprParam, ExprParams,
+	FieldMember, FieldName, ForSpecData, IfElse, IfSpecData, ImportKind, ObjBody, ParserSettings,
+	Slice, SliceDesc, Source, SourcePath, Spanned,
 };
 use rustc_hash::FxHashMap;
 
@@ -63,9 +63,9 @@
 			}
 		}
 	}
-	fn in_params(params: &ParamsDesc, out: &mut FoundImports) {
-		for Param(dest, default) in &*params.0 {
-			in_destruct(dest, out);
+	fn in_params(params: &ExprParams, out: &mut FoundImports) {
+		for ExprParam { destruct, default } in &*params.exprs {
+			in_destruct(destruct, out);
 			if let Some(expr) = default {
 				find_imports(expr, out);
 			}

--- a/crates/jrsonnet-evaluator/src/ctx.rs
+++ b/crates/jrsonnet-evaluator/src/ctx.rs
@@ -180,6 +180,12 @@
 		assert!(old.is_none(), "variable bound twice in single context call");
 		self
 	}
+	pub fn binds(&mut self, bindings: FxHashMap<IStr, Thunk<Val>>) -> &mut Self {
+		for (k, v) in bindings {
+			self.bind(k, v);
+		}
+		self
+	}
 	pub fn build(self) -> Context {
 		if let Some(parent) = self.extend {
 			parent.extend_bindings(self.bindings)

--- a/crates/jrsonnet-evaluator/src/error.rs
+++ b/crates/jrsonnet-evaluator/src/error.rs
@@ -1,7 +1,7 @@
 use std::{
 	cmp::Ordering,
 	convert::Infallible,
-	fmt::{Debug, Display},
+	fmt::{self, Debug, Display},
 };
 
 use jrsonnet_gcmodule::{Acyclic, Trace};
@@ -11,7 +11,7 @@
 use thiserror::Error;
 
 use crate::{
-	function::{builtin::ParamDefault, CallLocation},
+	function::{CallLocation, FunctionSignature, ParamDefault, ParamName},
 	stdlib::format::FormatError,
 	typed::TypeLocError,
 	val::ConvertNumValueError,
@@ -43,37 +43,7 @@
 			out.push_str(", ");
 		}
 		out.push_str(v as &str);
-	}
-	out
-}
-
-fn format_signature(sig: &FunctionSignature) -> String {
-	let mut out = String::new();
-	out.push_str("\nFunction has the following signature: ");
-	out.push('(');
-	if sig.is_empty() {
-		out.push_str("/*no arguments*/");
-	} else {
-		for (i, (name, default)) in sig.iter().enumerate() {
-			if i != 0 {
-				out.push_str(", ");
-			}
-			if let Some(name) = name {
-				out.push_str(name);
-			} else {
-				out.push_str("<unnamed>");
-			}
-			match default {
-				ParamDefault::None => {}
-				ParamDefault::Exists => out.push_str(" = <default>"),
-				ParamDefault::Literal(lit) => {
-					out.push_str(" = ");
-					out.push_str(lit);
-				}
-			}
-		}
 	}
-	out.push(')');
 	out
 }
 
@@ -103,8 +73,6 @@
 	heap.sort_by(|a, b| b.0.partial_cmp(&a.0).unwrap_or(Ordering::Equal));
 	heap.into_iter().map(|v| v.1).collect()
 }
-
-type FunctionSignature = Vec<(Option<IStr>, ParamDefault)>;
 
 /// Possible errors
 #[allow(missing_docs)]
@@ -148,13 +116,13 @@
 	#[error("only functions can be called, got {0}")]
 	OnlyFunctionsCanBeCalledGot(ValType),
 	#[error("parameter {0} is not defined")]
-	UnknownFunctionParameter(String),
+	UnknownFunctionParameter(IStr),
 	#[error("argument {0} is already bound")]
 	BindingParameterASecondTime(IStr),
-	#[error("too many args, function has {0}{sig}", sig = format_signature(.1))]
+	#[error("too many args, function has {0}\nFunction has the following signature: {1}")]
 	TooManyArgsFunctionHas(usize, FunctionSignature),
-	#[error("function argument is not passed: {}{}", .0.as_ref().map_or("<unnamed>", IStr::as_str), format_signature(.1))]
-	FunctionParameterNotBoundInCall(Option<IStr>, FunctionSignature),
+	#[error("function argument is not passed: {0}\nFunction has the following signature: {1}")]
+	FunctionParameterNotBoundInCall(ParamName, FunctionSignature),
 
 	#[error("external variable is not defined: {0}")]
 	UndefinedExternalVariable(IStr),

--- a/crates/jrsonnet-evaluator/src/evaluate/destructure.rs
+++ b/crates/jrsonnet-evaluator/src/evaluate/destructure.rs
@@ -170,7 +170,7 @@
 			let value = value.clone();
 			let data = {
 				let fctx = fctx.clone();
-				Thunk!(move || name.map_or_else(
+				Thunk!(move || name.0.map_or_else(
 					|| evaluate(fctx.unwrap(), &value),
 					|name| evaluate_named(fctx.unwrap(), &value, name),
 				))

--- a/crates/jrsonnet-evaluator/src/evaluate/mod.rs
+++ b/crates/jrsonnet-evaluator/src/evaluate/mod.rs
@@ -3,15 +3,27 @@
 use jrsonnet_gcmodule::{Cc, Trace};
 use jrsonnet_interner::IStr;
 use jrsonnet_parser::{
-	ArgsDesc, AssertStmt, BinaryOpType, BindSpec, CompSpec, Expr, FieldMember, FieldName,
-	ForSpecData, IfSpecData, ImportKind, LiteralType, ObjBody, ObjMembers, ParamsDesc, Spanned,
+	function::ParamName, ArgsDesc, AssertStmt, BinaryOpType, BindSpec, CompSpec, Expr, ExprParams,
+	FieldMember, FieldName, ForSpecData, IfSpecData, ImportKind, LiteralType, ObjBody, ObjMembers,
+	Spanned,
 };
 use jrsonnet_types::ValType;
 use rustc_hash::FxHashMap;
 
 use self::destructure::destruct;
 use crate::{
-	Context, Error, ObjValue, ObjValueBuilder, ObjectAssertion, Pending, Result, ResultExt, SupThis, Unbound, Val, arr::ArrValue, bail, destructure::evaluate_dest, error::{ErrorKind::*, suggest_object_fields}, evaluate::operator::{evaluate_add_op, evaluate_binary_op_special, evaluate_unary_op}, function::{CallLocation, FuncDesc, FuncVal, builtin::{ParamDefault, ParamName, ParamParse}}, gc::WithCapacityExt as _, in_frame, typed::Typed, val::{CachedUnbound, IndexableVal, NumValue, StrValue, Thunk}, with_state
+	arr::ArrValue,
+	bail,
+	destructure::evaluate_dest,
+	error::{suggest_object_fields, ErrorKind::*},
+	evaluate::operator::{evaluate_add_op, evaluate_binary_op_special, evaluate_unary_op},
+	function::{CallLocation, FuncDesc, FuncVal},
+	gc::WithCapacityExt as _,
+	in_frame,
+	typed::Typed,
+	val::{CachedUnbound, IndexableVal, NumValue, StrValue, Thunk},
+	with_state, Context, Error, ObjValue, ObjValueBuilder, ObjectAssertion, Pending, Result,
+	ResultExt, SupThis, Unbound, Val,
 };
 pub mod destructure;
 pub mod operator;
@@ -71,21 +83,12 @@
 pub fn evaluate_method(
 	ctx: Context,
 	name: IStr,
-	params: ParamsDesc,
+	params: ExprParams,
 	body: Rc<Spanned<Expr>>,
 ) -> Val {
 	Val::Func(FuncVal::Normal(Cc::new(FuncDesc {
 		name,
 		ctx,
-		params_parse: params
-			.iter()
-			.map(|p| {
-				ParamParse::new(
-					p.0.name().map_or(ParamName::ANONYMOUS, ParamName::new),
-					ParamDefault::exists(p.1.is_some()),
-				)
-			})
-			.collect(),
 		params,
 		body,
 	})))
@@ -125,7 +128,7 @@
 			Val::Arr(list) => {
 				for item in list.iter_lazy() {
 					let fctx = Pending::new();
-					let mut new_bindings = FxHashMap::with_capacity(var.capacity_hint());
+					let mut new_bindings = FxHashMap::with_capacity(var.binds_len());
 					destruct(var, item, fctx.clone(), &mut new_bindings)?;
 					let ctx = ctx.clone().extend_bindings(new_bindings).into_future(fctx);
 
@@ -178,7 +181,7 @@
 		fn bind(&self, sup_this: SupThis) -> Result<Context> {
 			let fctx = Context::new_future();
 			let mut new_bindings =
-				FxHashMap::with_capacity(self.locals.iter().map(BindSpec::capacity_hint).sum());
+				FxHashMap::with_capacity(self.locals.iter().map(BindSpec::binds_len).sum());
 			for b in self.locals.iter() {
 				evaluate_dest(b, fctx.clone(), &mut new_bindings)?;
 			}
@@ -249,7 +252,7 @@
 			struct UnboundMethod<B: Trace> {
 				uctx: B,
 				value: Rc<Spanned<Expr>>,
-				params: ParamsDesc,
+				params: ExprParams,
 				name: IStr,
 			}
 			impl<B: Unbound<Bound = Context>> Unbound for UnboundMethod<B> {
@@ -376,6 +379,13 @@
 	Ok(())
 }
 
+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),
+	}
+}
+
 pub fn evaluate_named(ctx: Context, expr: &Spanned<Expr>, name: IStr) -> Result<Val> {
 	use Expr::*;
 	Ok(match &**expr {
@@ -551,7 +561,7 @@
 		})?,
 		LocalExpr(bindings, returned) => {
 			let mut new_bindings: FxHashMap<IStr, Thunk<Val>> =
-				FxHashMap::with_capacity(bindings.iter().map(BindSpec::capacity_hint).sum());
+				FxHashMap::with_capacity(bindings.iter().map(BindSpec::binds_len).sum());
 			let fctx = Context::new_future();
 			for b in bindings {
 				evaluate_dest(b, fctx.clone(), &mut new_bindings)?;

--- a/crates/jrsonnet-evaluator/src/function/builtin.rs
+++ b/crates/jrsonnet-evaluator/src/function/builtin.rs
@@ -1,82 +1,25 @@
 use std::any::Any;
+use std::fmt;
 
 use jrsonnet_gcmodule::{cc_dyn, Acyclic, Trace, TraceBox};
 use jrsonnet_interner::IStr;
+use jrsonnet_parser::function::{FunctionSignature, ParamDefault, ParamName, ParamParse};
 
 use super::{arglike::ArgsLike, parse::parse_builtin_call, CallLocation};
 use crate::{Context, Result, Val};
 
-#[derive(Clone, Acyclic)]
-pub struct ParamName(Option<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()
-	}
-	pub fn is_anonymous(&self) -> bool {
-		self.0.is_none()
-	}
-}
-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())
-	}
-}
-
-#[derive(Clone, Copy, Debug, Acyclic)]
-pub enum ParamDefault {
-	None,
-	Exists,
-	Literal(&'static str),
-}
-impl ParamDefault {
-	pub const fn exists(is_exists: bool) -> Self {
-		if is_exists {
-			Self::Exists
-		} else {
-			Self::None
-		}
-	}
-}
-
 #[macro_export]
 macro_rules! params {
 	(@name unnamed) => { ParamName::ANONYMOUS };
 	(@name named $name:literal) => { ParamName::new($crate::IStr::from($name)) };
 	($($(#[$meta:meta])* [$kind:ident $(($lit:literal))? => $default:expr]),* $(,)?) => {
 		thread_local! {
-			static PARAMS: [ParamParse; { const N: usize = <[u8]>::len(&[$($(#[$meta])* 0u8),*]); N }] = [
+			static PARAMS: FunctionSignature = FunctionSignature::new([
 				$($(#[$meta])* ParamParse::new(params!(@name $kind $($lit)?), $default)),*
-			];
+			].into());
 		}
 	};
-}
-
-#[derive(Clone, Acyclic)]
-pub struct ParamParse {
-	name: ParamName,
-	default: ParamDefault,
 }
-impl ParamParse {
-	pub fn new(name: ParamName, default: ParamDefault) -> Self {
-		Self { name, default }
-	}
-	/// Parameter name for named call parsing
-	pub fn name(&self) -> &ParamName {
-		&self.name
-	}
-	pub fn default(&self) -> ParamDefault {
-		self.default
-	}
-	pub fn has_default(&self) -> bool {
-		!matches!(self.default, ParamDefault::None)
-	}
-}
 
 cc_dyn!(
 	#[derive(Clone)]
@@ -89,7 +32,7 @@
 		self.0.name()
 	}
 
-	fn params(&self) -> &[ParamParse] {
+	fn params(&self) -> FunctionSignature {
 		self.0.params()
 	}
 
@@ -109,7 +52,7 @@
 	/// Function name to be used in stack traces
 	fn name(&self) -> &str;
 	/// Parameter names for named calls
-	fn params(&self) -> &[ParamParse];
+	fn params(&self) -> FunctionSignature;
 	/// Call the builtin
 	fn call(&self, ctx: Context, loc: CallLocation<'_>, args: &dyn ArgsLike) -> Result<Val>;
 
@@ -126,20 +69,19 @@
 
 #[derive(Trace)]
 pub struct NativeCallback {
-	pub(crate) params: Vec<ParamParse>,
+	pub(crate) params: FunctionSignature,
 	handler: TraceBox<dyn NativeCallbackHandler>,
 }
 impl NativeCallback {
 	#[deprecated = "prefer using builtins directly, use this interface only for bindings"]
 	pub fn new(params: Vec<String>, handler: impl NativeCallbackHandler) -> Self {
 		Self {
-			params: params
-				.into_iter()
-				.map(|n| ParamParse {
-					name: ParamName::new(n.into()),
-					default: ParamDefault::None,
-				})
-				.collect(),
+			params: FunctionSignature::new(
+				params
+					.into_iter()
+					.map(|n| ParamParse::new(ParamName::new(n.into()), ParamDefault::None))
+					.collect(),
+			),
 			handler: TraceBox(Box::new(handler)),
 		}
 	}
@@ -152,12 +94,12 @@
 		"<native>"
 	}
 
-	fn params(&self) -> &[ParamParse] {
-		&self.params
+	fn params(&self) -> FunctionSignature {
+		self.params.clone()
 	}
 
 	fn call(&self, ctx: Context, _loc: CallLocation<'_>, args: &dyn ArgsLike) -> Result<Val> {
-		let args = parse_builtin_call(ctx, &self.params, args, true)?;
+		let args = parse_builtin_call(ctx, self.params.clone(), args, true)?;
 		let args = args
 			.into_iter()
 			.map(|a| a.expect("legacy natives have no default params"))

--- a/crates/jrsonnet-evaluator/src/function/mod.rs
+++ b/crates/jrsonnet-evaluator/src/function/mod.rs
@@ -5,23 +5,26 @@
 use jrsonnet_gcmodule::{Cc, Trace};
 use jrsonnet_interner::IStr;
 pub use jrsonnet_macros::builtin;
-use jrsonnet_parser::{Destruct, Expr, ParamsDesc, Span, Spanned};
+use jrsonnet_parser::{Destruct, Expr, ExprParams, Span, Spanned};
 
 use self::{
 	arglike::OptionalContext,
-	builtin::{Builtin, ParamParse, StaticBuiltin},
+	builtin::{Builtin, StaticBuiltin},
 	native::NativeDesc,
 	parse::{parse_default_function_call, parse_function_call},
 };
 use crate::{
-	bail, error::ErrorKind::*, evaluate, evaluate_trivial, function::builtin::BuiltinFunc, Context,
-	ContextBuilder, Result, Thunk, Val,
+	bail, error::ErrorKind::*, evaluate, evaluate_trivial, function::builtin::BuiltinFunc, params,
+	Context, ContextBuilder, Result, Thunk, Val,
 };
 
 pub mod arglike;
 pub mod builtin;
 pub mod native;
 pub mod parse;
+pub mod prepared;
+
+pub use jrsonnet_parser::function::*;
 
 /// Function callsite location.
 /// Either from other jsonnet code, specified by expression location, or from native (without location).
@@ -66,12 +69,9 @@
 	pub ctx: Context,
 
 	/// Function parameter definition
-	pub params: ParamsDesc,
+	pub params: ExprParams,
 	/// Function body
 	pub body: Rc<Spanned<Expr>>,
-
-	#[educe(PartialEq = false, Debug = false)]
-	pub(crate) params_parse: Vec<ParamParse>,
 }
 impl FuncDesc {
 	/// Create body context, but fill arguments without defaults with lazy error
@@ -139,24 +139,18 @@
 		Self::StaticBuiltin(static_builtin)
 	}
 
-	pub fn params(&self) -> &[ParamParse] {
+	pub fn params(&self) -> FunctionSignature {
 		match self {
 			Self::Id => ID.params(),
 			Self::StaticBuiltin(i) => i.params(),
 			Self::Builtin(i) => i.params(),
-			Self::Normal(p) => &p.params_parse,
-			Self::Thunk(_) => &[],
+			Self::Normal(p) => p.params.signature.clone(),
+			Self::Thunk(_) => FunctionSignature::empty(),
 		}
 	}
 	/// Amount of non-default required arguments
 	pub fn params_len(&self) -> usize {
-		match self {
-			Self::Id => 1,
-			Self::Normal(n) => n.params.iter().filter(|p| p.1.is_none()).count(),
-			Self::StaticBuiltin(i) => i.params().iter().filter(|p| !p.has_default()).count(),
-			Self::Builtin(i) => i.params().iter().filter(|p| !p.has_default()).count(),
-			Self::Thunk(_) => 0,
-		}
+		self.params().iter().filter(|p| !p.has_default()).count()
 	}
 	/// Function name, as defined in code.
 	pub fn name(&self) -> IStr {
@@ -185,8 +179,8 @@
 				evaluate(body_ctx, &func.body)
 			}
 			Self::Thunk(thunk) => {
-				if args.is_empty() {
-					bail!(TooManyArgsFunctionHas(0, vec![],))
+				if !args.is_empty() {
+					bail!(TooManyArgsFunctionHas(0, FunctionSignature::empty()))
 				}
 				thunk.evaluate()
 			}
@@ -223,12 +217,13 @@
 				if desc.params.len() != 1 {
 					return false;
 				}
-				let param = &desc.params[0];
-				if param.1.is_some() {
+				let param = &desc.params.exprs[0];
+				if param.default.is_some() {
 					return false;
 				}
+
 				#[allow(clippy::infallible_destructuring_match)]
-				let id = match &param.0 {
+				let id = match &param.destruct {
 					Destruct::Full(id) => id,
 					#[cfg(feature = "exp-destruct")]
 					_ => return false,

--- a/crates/jrsonnet-evaluator/src/function/parse.rs
+++ b/crates/jrsonnet-evaluator/src/function/parse.rs
@@ -1,16 +1,15 @@
 use std::mem::replace;
 
 use jrsonnet_interner::IStr;
-use jrsonnet_parser::ParamsDesc;
+use jrsonnet_parser::{function::FunctionSignature, ExprParams};
 use rustc_hash::FxHashMap;
 
-use super::{arglike::ArgsLike, builtin::ParamParse};
+use super::arglike::ArgsLike;
 use crate::{
 	bail,
 	destructure::destruct,
 	error::{ErrorKind::*, Result},
-	evaluate_named,
-	function::builtin::ParamDefault,
+	evaluate_named, evaluate_named_param,
 	gc::WithCapacityExt as _,
 	Context, Pending, Thunk, Val,
 };
@@ -26,19 +25,15 @@
 pub fn parse_function_call(
 	ctx: Context,
 	body_ctx: Context,
-	params: &ParamsDesc,
+	params: &ExprParams,
 	args: &dyn ArgsLike,
 	tailstrict: bool,
 ) -> Result<Context> {
-	let mut passed_args =
-		FxHashMap::with_capacity(params.iter().map(|p| p.0.capacity_hint()).sum());
-	if args.unnamed_len() > params.len() {
+	let mut passed_args = FxHashMap::with_capacity(params.binds_len());
+	if args.unnamed_len() > params.signature.len() {
 		bail!(TooManyArgsFunctionHas(
-			params.len(),
-			params
-				.iter()
-				.map(|p| (p.0.name(), ParamDefault::exists(p.1.is_some())))
-				.collect()
+			params.signature.len(),
+			params.signature.clone(),
 		))
 	}
 
@@ -46,9 +41,8 @@
 	let mut filled_positionals = 0;
 
 	args.unnamed_iter(ctx.clone(), tailstrict, &mut |id, arg| {
-		let name = params[id].0.clone();
 		destruct(
-			&name,
+			&params.exprs[id].destruct,
 			arg,
 			Pending::new_filled(ctx.clone()),
 			&mut passed_args,
@@ -59,8 +53,8 @@
 
 	args.named_iter(ctx, tailstrict, &mut |name, value| {
 		// FIXME: O(n) for arg existence check
-		if !params.iter().any(|p| p.0.name().as_ref() == Some(name)) {
-			bail!(UnknownFunctionParameter((name as &str).to_owned()));
+		if !params.exprs.iter().any(|p| &p.destruct.name() == name) {
+			bail!(UnknownFunctionParameter(name.clone()));
 		}
 		if passed_args.insert(name.clone(), value).is_some() {
 			bail!(BindingParameterASecondTime(name.clone()));
@@ -73,14 +67,16 @@
 		// Some args are unset, but maybe we have defaults for them
 		// Default values should be created in newly created context
 		let fctx = Context::new_future();
-		let mut defaults = FxHashMap::with_capacity(
-			params.iter().map(|p| p.0.capacity_hint()).sum::<usize>()
-				- filled_named
-				- filled_positionals,
-		);
+		let mut defaults =
+			FxHashMap::with_capacity(params.binds_len() - filled_named - filled_positionals);
 
-		for (idx, param) in params.iter().enumerate().filter(|p| p.1 .1.is_some()) {
-			if let Some(name) = param.0.name() {
+		for (idx, into, default) in params
+			.exprs
+			.iter()
+			.enumerate()
+			.filter_map(|(i, p)| Some((i, &p.destruct, p.default.as_ref()?)))
+		{
+			if let Some(name) = into.name().0 {
 				if passed_args.contains_key(&name) {
 					continue;
 				}
@@ -89,17 +85,17 @@
 			}
 
 			destruct(
-				&param.0,
+				&into,
 				{
 					let ctx = fctx.clone();
-					let name = param.0.name().unwrap_or_else(|| "<destruct>".into());
-					let value = param.1.clone().expect("default exists");
-					Thunk!(move || evaluate_named(ctx.unwrap(), &value, name))
+					let name = into.name();
+					let value = default.clone();
+					Thunk!(move || evaluate_named_param(ctx.unwrap(), &value, name))
 				},
 				fctx.clone(),
 				&mut defaults,
 			)?;
-			if param.0.name().is_some() {
+			if !into.name().is_anonymous() {
 				filled_named += 1;
 			} else {
 				filled_positionals += 1;
@@ -108,20 +104,17 @@
 
 		// Some args still weren't filled
 		if filled_named + filled_positionals != params.len() {
-			for param in params.iter().skip(args.unnamed_len()) {
+			for param in params.exprs.iter().skip(args.unnamed_len()) {
 				let mut found = false;
 				args.named_names(&mut |name| {
-					if Some(name) == param.0.name().as_ref() {
+					if &param.destruct.name() == name {
 						found = true;
 					}
 				});
 				if !found {
 					bail!(FunctionParameterNotBoundInCall(
-						param.0.clone().name(),
-						params
-							.iter()
-							.map(|p| (p.0.name(), ParamDefault::exists(p.1.is_some())))
-							.collect()
+						param.destruct.name(),
+						params.signature.clone()
 					));
 				}
 			}
@@ -147,19 +140,13 @@
 /// * `tailstrict`: if set to `true` function arguments are eagerly executed, otherwise - lazily
 pub fn parse_builtin_call(
 	ctx: Context,
-	params: &[ParamParse],
+	params: FunctionSignature,
 	args: &dyn ArgsLike,
 	tailstrict: bool,
 ) -> Result<Vec<Option<Thunk<Val>>>> {
 	let mut passed_args: Vec<Option<Thunk<Val>>> = vec![None; params.len()];
 	if args.unnamed_len() > params.len() {
-		bail!(TooManyArgsFunctionHas(
-			params.len(),
-			params
-				.iter()
-				.map(|p| (p.name().as_str().map(IStr::from), p.default()))
-				.collect()
-		))
+		bail!(TooManyArgsFunctionHas(params.len(), params,))
 	}
 
 	let mut filled_args = 0;
@@ -175,7 +162,7 @@
 		let id = params
 			.iter()
 			.position(|p| p.name() == name)
-			.ok_or_else(|| UnknownFunctionParameter((name as &str).to_owned()))?;
+			.ok_or_else(|| UnknownFunctionParameter(name.clone()))?;
 		if replace(&mut passed_args[id], Some(arg)).is_some() {
 			bail!(BindingParameterASecondTime(name.clone()));
 		}
@@ -202,11 +189,8 @@
 				});
 				if !found {
 					bail!(FunctionParameterNotBoundInCall(
-						param.name().as_str().map(IStr::from),
-						params
-							.iter()
-							.map(|p| (p.name().as_str().map(IStr::from), p.default()))
-							.collect()
+						param.name().clone(),
+						params,
 					));
 				}
 			}
@@ -218,36 +202,33 @@
 
 /// Creates Context, which has all argument default values applied
 /// and with unbound values causing error to be returned
-pub fn parse_default_function_call(body_ctx: Context, params: &ParamsDesc) -> Result<Context> {
+pub fn parse_default_function_call(body_ctx: Context, params: &ExprParams) -> Result<Context> {
 	let fctx = Context::new_future();
 
-	let mut bindings = FxHashMap::with_capacity(params.iter().map(|p| p.0.capacity_hint()).sum());
+	let mut bindings = FxHashMap::with_capacity(params.binds_len());
 
-	for param in params.iter() {
-		if let Some(v) = &param.1 {
+	for param in params.exprs.iter() {
+		if let Some(v) = &param.default {
 			destruct(
-				&param.0.clone(),
+				&param.destruct.clone(),
 				{
 					let ctx = fctx.clone();
-					let name = param.0.name().unwrap_or_else(|| "<destruct>".into());
+					let name = param.destruct.name();
 					let value = v.clone();
-					Thunk!(move || evaluate_named(ctx.unwrap(), &value, name))
+					Thunk!(move || evaluate_named_param(ctx.unwrap(), &value, name))
 				},
 				fctx.clone(),
 				&mut bindings,
 			)?;
 		} else {
 			destruct(
-				&param.0,
+				&param.destruct,
 				{
-					let param_name = param.0.name().unwrap_or_else(|| "<destruct>".into());
+					let param_name = param.destruct.name();
 					let params = params.clone();
 					Thunk!(move || Err(FunctionParameterNotBoundInCall(
-						Some(param_name),
-						params
-							.iter()
-							.map(|p| (p.0.name(), ParamDefault::exists(p.1.is_some())))
-							.collect(),
+						param_name,
+						params.signature.clone()
 					)
 					.into()))
 				},

--- a/crates/jrsonnet-evaluator/src/stack.rs
+++ b/crates/jrsonnet-evaluator/src/stack.rs
@@ -20,6 +20,7 @@
 type NightlyLocalKey<T> = std::thread::LocalKey<T>;
 
 #[cfg(nightly)]
+#[macro_export]
 macro_rules! const_tls {
 	(const $name:ident: $t:ty = $expr:expr;) => {
 		#[thread_local]
@@ -27,6 +28,7 @@
 	};
 }
 #[cfg(not(nightly))]
+#[macro_export]
 macro_rules! const_tls {
 	(const $name:ident: $t:ty = $expr:expr;) => {
 		thread_local! {

--- a/crates/jrsonnet-parser/src/expr.rs
+++ b/crates/jrsonnet-parser/src/expr.rs
@@ -7,7 +7,10 @@
 use jrsonnet_gcmodule::Acyclic;
 use jrsonnet_interner::IStr;
 
-use crate::source::Source;
+use crate::{
+	function::{FunctionSignature, ParamDefault, ParamName, ParamParse},
+	source::Source,
+};
 
 #[derive(Debug, PartialEq, Acyclic)]
 pub enum FieldName {
@@ -41,7 +44,7 @@
 pub struct FieldMember {
 	pub name: FieldName,
 	pub plus: bool,
-	pub params: Option<ParamsDesc>,
+	pub params: Option<ExprParams>,
 	pub visibility: Visibility,
 	pub value: Rc<Spanned<Expr>>,
 }
@@ -147,16 +150,41 @@
 
 /// name, default value
 #[derive(Debug, PartialEq, Acyclic)]
-pub struct Param(pub Destruct, pub Option<Rc<Spanned<Expr>>>);
+pub struct ExprParam {
+	pub destruct: Destruct,
+	pub default: Option<Rc<Spanned<Expr>>>,
+}
 
 /// Defined function parameters
 #[derive(Debug, Clone, PartialEq, Acyclic)]
-pub struct ParamsDesc(pub Rc<Vec<Param>>);
-
-impl Deref for ParamsDesc {
-	type Target = Vec<Param>;
-	fn deref(&self) -> &Self::Target {
-		&self.0
+pub struct ExprParams {
+	pub exprs: Rc<Vec<ExprParam>>,
+	pub signature: FunctionSignature,
+	binds_len: usize,
+}
+impl ExprParams {
+	pub fn len(&self) -> usize {
+		self.exprs.len()
+	}
+	pub fn binds_len(&self) -> usize {
+		self.binds_len
+	}
+	pub fn new(exprs: Vec<ExprParam>) -> Self {
+		Self {
+			signature: FunctionSignature::new(
+				exprs
+					.iter()
+					.map(|p| {
+						ParamParse::new(
+							p.destruct.name(),
+							ParamDefault::exists(p.default.is_some()),
+						)
+					})
+					.collect(),
+			),
+			binds_len: exprs.iter().map(|v| v.destruct.binds_len()).sum(),
+			exprs: Rc::new(exprs),
+		}
 	}
 }
 
@@ -198,14 +226,14 @@
 }
 impl Destruct {
 	/// Name of destructure, used for function parameter names
-	pub fn name(&self) -> Option<IStr> {
-		match self {
+	pub fn name(&self) -> ParamName {
+		ParamName(match self {
 			Self::Full(name) => Some(name.clone()),
 			#[cfg(feature = "exp-destruct")]
 			_ => None,
-		}
+		})
 	}
-	pub fn capacity_hint(&self) -> usize {
+	pub fn binds_len(&self) -> usize {
 		#[cfg(feature = "exp-destruct")]
 		fn cap_rest(rest: &Option<DestructRest>) -> usize {
 			match rest {
@@ -220,8 +248,8 @@
 			Self::Skip => 0,
 			#[cfg(feature = "exp-destruct")]
 			Self::Array { start, rest, end } => {
-				start.iter().map(Destruct::capacity_hint).sum::<usize>()
-					+ end.iter().map(Destruct::capacity_hint).sum::<usize>()
+				start.iter().map(Destruct::binds_len).sum::<usize>()
+					+ end.iter().map(Destruct::binds_len).sum::<usize>()
 					+ cap_rest(rest)
 			}
 			#[cfg(feature = "exp-destruct")]
@@ -248,14 +276,14 @@
 	},
 	Function {
 		name: IStr,
-		params: ParamsDesc,
+		params: ExprParams,
 		value: Rc<Spanned<Expr>>,
 	},
 }
 impl BindSpec {
-	pub fn capacity_hint(&self) -> usize {
+	pub fn binds_len(&self) -> usize {
 		match self {
-			BindSpec::Field { into, .. } => into.capacity_hint(),
+			BindSpec::Field { into, .. } => into.binds_len(),
 			BindSpec::Function { .. } => 1,
 		}
 	}
@@ -396,7 +424,7 @@
 		parts: Vec<IndexPart>,
 	},
 	/// function(x) x
-	Function(ParamsDesc, Rc<Spanned<Expr>>),
+	Function(ExprParams, Rc<Spanned<Expr>>),
 	/// if true == false then 1 else 2
 	IfElse(Box<IfElse>),
 	Slice(Box<Slice>),

--- a/crates/jrsonnet-parser/src/lib.rs
+++ b/crates/jrsonnet-parser/src/lib.rs
@@ -7,9 +7,11 @@
 pub use expr::*;
 pub use jrsonnet_interner::IStr;
 pub use peg;
+pub mod function;
 mod location;
 mod source;
 mod unescape;
+
 pub use location::CodeLocation;
 pub use source::{
 	Source, SourceDefaultIgnoreJpath, SourceDirectory, SourceFifo, SourceFile, SourcePath,
@@ -68,10 +70,10 @@
 		rule keyword(id: &'static str) -> ()
 			= ##parse_string_literal(id) end_of_ident()
 
-		pub rule param(s: &ParserSettings) -> expr::Param = name:destruct(s) expr:(_ "=" _ expr:expr(s){expr})? { expr::Param(name, expr.map(Rc::new)) }
-		pub rule params(s: &ParserSettings) -> expr::ParamsDesc
-			= params:param(s) ** comma() comma()? { expr::ParamsDesc(Rc::new(params)) }
-			/ { expr::ParamsDesc(Rc::new(Vec::new())) }
+		pub rule param(s: &ParserSettings) -> expr::ExprParam = destruct:destruct(s) expr:(_ "=" _ expr:expr(s){expr})? { expr::ExprParam { destruct, default: expr.map(Rc::new) } }
+		pub rule params(s: &ParserSettings) -> expr::ExprParams
+			= params:param(s) ** comma() comma()? { expr::ExprParams::new(params) }
+			/ { expr::ExprParams::new(Vec::new()) }
 
 		pub rule arg(s: &ParserSettings) -> (Option<IStr>, Rc<Spanned<Expr>>)
 			= name:(quiet! { (s:id() _ "=" !['='] _ {s})? } / expected!("<argument name>")) expr:expr(s) {(name, Rc::new(expr))}

--- 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
@@ -6,26 +6,47 @@
     [
         Function {
             name: "x",
-            params: ParamsDesc(
-                [
-                    Param(
-                        Full(
+            params: ExprParams {
+                exprs: [
+                    ExprParam {
+                        destruct: Full(
                             "foo",
                         ),
-                        Some(
+                        default: Some(
                             Str(
                                 "foo",
                             ) from virtual:<test>:14-19,
                         ),
-                    ),
-                    Param(
-                        Full(
+                    },
+                    ExprParam {
+                        destruct: Full(
                             "bar",
                         ),
-                        None,
-                    ),
+                        default: None,
+                    },
                 ],
-            ),
+                signature: FunctionSignature(
+                    [
+                        ParamParse {
+                            name: ParamName(
+                                Some(
+                                    "foo",
+                                ),
+                            ),
+                            default: Exists,
+                        },
+                        ParamParse {
+                            name: ParamName(
+                                Some(
+                                    "bar",
+                                ),
+                            ),
+                            default: None,
+                        },
+                    ],
+                ),
+                binds_len: 2,
+            },
             value: Literal(
                 Null,
             ) from virtual:<test>:28-32,