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

--- /dev/null
+++ b/crates/jrsonnet-evaluator/src/typed/conversions.rs
@@ -0,0 +1,508 @@
+use std::convert::{TryFrom, TryInto};
+
+use gcmodule::Cc;
+use jrsonnet_interner::IStr;
+use jrsonnet_types::{ComplexValType, ValType};
+
+use crate::{
+	error::{Error::*, LocError, Result},
+	throw,
+	typed::CheckType,
+	ArrValue, FuncVal, IndexableVal, ObjValue, Val,
+};
+
+pub trait Typed: TryFrom<Val, Error = LocError> + TryInto<Val, Error = LocError> {
+	const TYPE: &'static ComplexValType;
+}
+
+macro_rules! impl_int {
+	($($ty:ty)*) => {$(
+		impl Typed for $ty {
+			const TYPE: &'static ComplexValType =
+				&ComplexValType::BoundedNumber(Some(<$ty>::MIN as f64), Some(<$ty>::MAX as f64));
+		}
+		impl TryFrom<Val> for $ty {
+			type Error = LocError;
+
+			fn try_from(value: Val) -> Result<Self> {
+				<Self as Typed>::TYPE.check(&value)?;
+				match value {
+					Val::Num(n) => {
+						if n.trunc() != n {
+							throw!(RuntimeError(
+								format!(
+									"cannot convert number with fractional part to {}",
+									stringify!($ty)
+								)
+								.into()
+							))
+						}
+						Ok(n as $ty)
+					}
+					_ => unreachable!(),
+				}
+			}
+		}
+		impl TryFrom<$ty> for Val {
+			type Error = LocError;
+
+			fn try_from(value: $ty) -> Result<Self> {
+				Ok(Self::Num(value as f64))
+			}
+		}
+	)*};
+}
+
+impl_int!(i8 u8 i16 u16 i32 u32);
+
+impl Typed for f64 {
+	const TYPE: &'static ComplexValType = &ComplexValType::Simple(ValType::Num);
+}
+impl TryFrom<Val> for f64 {
+	type Error = LocError;
+
+	fn try_from(value: Val) -> Result<Self> {
+		<Self as Typed>::TYPE.check(&value)?;
+		match value {
+			Val::Num(n) => Ok(n),
+			_ => unreachable!(),
+		}
+	}
+}
+impl TryFrom<f64> for Val {
+	type Error = LocError;
+
+	fn try_from(value: f64) -> Result<Self> {
+		Ok(Self::Num(value))
+	}
+}
+
+pub struct PositiveF64(pub f64);
+impl Typed for PositiveF64 {
+	const TYPE: &'static ComplexValType = &ComplexValType::BoundedNumber(Some(0.0), None);
+}
+impl TryFrom<Val> for PositiveF64 {
+	type Error = LocError;
+
+	fn try_from(value: Val) -> Result<Self> {
+		<Self as Typed>::TYPE.check(&value)?;
+		match value {
+			Val::Num(n) => Ok(Self(n)),
+			_ => unreachable!(),
+		}
+	}
+}
+impl TryFrom<PositiveF64> for Val {
+	type Error = LocError;
+
+	fn try_from(value: PositiveF64) -> Result<Self> {
+		Ok(Self::Num(value.0))
+	}
+}
+
+impl Typed for usize {
+	// It is possible to store 54 bits of precision in f64, but leaving u32::MAX here for compatibility
+	const TYPE: &'static ComplexValType =
+		&ComplexValType::BoundedNumber(Some(0.0), Some(4294967295.0));
+}
+impl TryFrom<Val> for usize {
+	type Error = LocError;
+
+	fn try_from(value: Val) -> Result<Self> {
+		<Self as Typed>::TYPE.check(&value)?;
+		match value {
+			Val::Num(n) => {
+				if n.trunc() != n {
+					throw!(RuntimeError(
+						"cannot convert number with fractional part to usize".into()
+					))
+				}
+				Ok(n as Self)
+			}
+			_ => unreachable!(),
+		}
+	}
+}
+impl TryFrom<usize> for Val {
+	type Error = LocError;
+
+	fn try_from(value: usize) -> Result<Self> {
+		if value > u32::MAX as usize {
+			throw!(RuntimeError("number is too large".into()))
+		}
+		Ok(Self::Num(value as f64))
+	}
+}
+
+impl Typed for IStr {
+	const TYPE: &'static ComplexValType = &ComplexValType::Simple(ValType::Str);
+}
+impl TryFrom<Val> for IStr {
+	type Error = LocError;
+
+	fn try_from(value: Val) -> Result<Self> {
+		<Self as Typed>::TYPE.check(&value)?;
+		match value {
+			Val::Str(s) => Ok(s),
+			_ => unreachable!(),
+		}
+	}
+}
+impl TryFrom<IStr> for Val {
+	type Error = LocError;
+
+	fn try_from(value: IStr) -> Result<Self> {
+		Ok(Self::Str(value))
+	}
+}
+
+impl Typed for String {
+	const TYPE: &'static ComplexValType = &ComplexValType::Simple(ValType::Str);
+}
+impl TryFrom<Val> for String {
+	type Error = LocError;
+
+	fn try_from(value: Val) -> Result<Self> {
+		<Self as Typed>::TYPE.check(&value)?;
+		match value {
+			Val::Str(s) => Ok(s.to_string()),
+			_ => unreachable!(),
+		}
+	}
+}
+impl TryFrom<String> for Val {
+	type Error = LocError;
+
+	fn try_from(value: String) -> Result<Self> {
+		Ok(Self::Str(value.into()))
+	}
+}
+
+impl Typed for char {
+	const TYPE: &'static ComplexValType = &ComplexValType::Char;
+}
+impl TryFrom<Val> for char {
+	type Error = LocError;
+
+	fn try_from(value: Val) -> Result<Self> {
+		<Self as Typed>::TYPE.check(&value)?;
+		match value {
+			Val::Str(s) => Ok(s.chars().next().unwrap()),
+			_ => unreachable!(),
+		}
+	}
+}
+impl TryFrom<char> for Val {
+	type Error = LocError;
+
+	fn try_from(value: char) -> Result<Self> {
+		Ok(Self::Str(value.to_string().into()))
+	}
+}
+
+impl<T> Typed for Vec<T>
+where
+	T: Typed,
+	T: TryFrom<Val, Error = LocError>,
+	T: TryInto<Val, Error = LocError>,
+{
+	const TYPE: &'static ComplexValType = &ComplexValType::ArrayRef(T::TYPE);
+}
+impl<T> TryFrom<Val> for Vec<T>
+where
+	T: Typed,
+	T: TryFrom<Val, Error = LocError>,
+	T: TryInto<Val, Error = LocError>,
+{
+	type Error = LocError;
+
+	fn try_from(value: Val) -> Result<Self> {
+		<Self as Typed>::TYPE.check(&value)?;
+		match value {
+			Val::Arr(a) => {
+				let mut o = Self::with_capacity(a.len());
+				for i in a.iter() {
+					o.push(T::try_from(i?)?);
+				}
+				Ok(o)
+			}
+			_ => unreachable!(),
+		}
+	}
+}
+impl<T> TryFrom<Vec<T>> for Val
+where
+	T: Typed,
+	T: TryFrom<Self, Error = LocError>,
+	T: TryInto<Self, Error = LocError>,
+{
+	type Error = LocError;
+
+	fn try_from(value: Vec<T>) -> Result<Self> {
+		let mut o = Vec::with_capacity(value.len());
+		for i in value {
+			o.push(i.try_into()?);
+		}
+		Ok(Self::Arr(o.into()))
+	}
+}
+
+/// To be used in Vec<Any>
+/// Regular Val can't be used here, because it has wrong TryFrom::Error type
+pub struct Any(pub Val);
+
+impl Typed for Any {
+	const TYPE: &'static ComplexValType = &ComplexValType::Any;
+}
+impl TryFrom<Val> for Any {
+	type Error = LocError;
+
+	fn try_from(value: Val) -> Result<Self> {
+		Ok(Self(value))
+	}
+}
+impl TryFrom<Any> for Val {
+	type Error = LocError;
+
+	fn try_from(value: Any) -> Result<Self> {
+		Ok(value.0)
+	}
+}
+
+/// Specialization, provides faster TryFrom<VecVal> for Val
+pub struct VecVal(pub Vec<Val>);
+
+impl Typed for VecVal {
+	const TYPE: &'static ComplexValType = &ComplexValType::Simple(ValType::Arr);
+}
+impl TryFrom<Val> for VecVal {
+	type Error = LocError;
+
+	fn try_from(value: Val) -> Result<Self> {
+		<Self as Typed>::TYPE.check(&value)?;
+		match value {
+			Val::Arr(a) => Ok(Self(a.evaluated()?.to_vec())),
+			_ => unreachable!(),
+		}
+	}
+}
+impl TryFrom<VecVal> for Val {
+	type Error = LocError;
+
+	fn try_from(value: VecVal) -> Result<Self> {
+		Ok(Self::Arr(value.0.into()))
+	}
+}
+
+pub struct M1;
+impl Typed for M1 {
+	const TYPE: &'static ComplexValType = &ComplexValType::BoundedNumber(Some(-1.0), Some(-1.0));
+}
+impl TryFrom<Val> for M1 {
+	type Error = LocError;
+
+	fn try_from(value: Val) -> Result<Self> {
+		<Self as Typed>::TYPE.check(&value)?;
+		Ok(Self)
+	}
+}
+impl TryFrom<M1> for Val {
+	type Error = LocError;
+
+	fn try_from(_: M1) -> Result<Self> {
+		Ok(Self::Num(-1.0))
+	}
+}
+
+pub enum Either<A, B> {
+	Left(A),
+	Right(B),
+}
+
+impl<A, B> Either<A, B> {
+	pub fn to_left(self, f: impl FnOnce(B) -> A) -> A {
+		match self {
+			Either::Left(l) => l,
+			Either::Right(r) => f(r),
+		}
+	}
+	#[allow(clippy::missing_const_for_fn)]
+	pub fn left(self) -> Option<A> {
+		match self {
+			Either::Left(a) => Some(a),
+			Either::Right(_) => None,
+		}
+	}
+}
+
+impl<A, B> Typed for Either<A, B>
+where
+	A: Typed,
+	B: Typed,
+{
+	const TYPE: &'static ComplexValType = &ComplexValType::UnionRef(&[A::TYPE, B::TYPE]);
+}
+impl<A, B> TryFrom<Val> for Either<A, B>
+where
+	A: Typed,
+	B: Typed,
+{
+	type Error = LocError;
+
+	fn try_from(value: Val) -> Result<Self> {
+		if A::TYPE.check(&value).is_ok() {
+			A::try_from(value).map(Self::Left)
+		} else if B::TYPE.check(&value).is_ok() {
+			B::try_from(value).map(Self::Right)
+		} else {
+			<Self as Typed>::TYPE.check(&value)?;
+			unreachable!()
+		}
+	}
+}
+impl<A, B> TryFrom<Either<A, B>> for Val
+where
+	A: Typed,
+	B: Typed,
+{
+	type Error = LocError;
+
+	fn try_from(value: Either<A, B>) -> Result<Self> {
+		match value {
+			Either::Left(a) => a.try_into(),
+			Either::Right(b) => b.try_into(),
+		}
+	}
+}
+
+impl Typed for ArrValue {
+	const TYPE: &'static ComplexValType = &ComplexValType::Simple(ValType::Arr);
+}
+impl TryFrom<Val> for ArrValue {
+	type Error = LocError;
+
+	fn try_from(value: Val) -> Result<Self> {
+		<Self as Typed>::TYPE.check(&value)?;
+		match value {
+			Val::Arr(a) => Ok(a),
+			_ => unreachable!(),
+		}
+	}
+}
+impl TryFrom<ArrValue> for Val {
+	type Error = LocError;
+
+	fn try_from(value: ArrValue) -> Result<Self> {
+		Ok(Self::Arr(value))
+	}
+}
+
+impl Typed for Cc<FuncVal> {
+	const TYPE: &'static ComplexValType = &ComplexValType::Simple(ValType::Func);
+}
+impl TryFrom<Val> for Cc<FuncVal> {
+	type Error = LocError;
+
+	fn try_from(value: Val) -> Result<Self> {
+		<Self as Typed>::TYPE.check(&value)?;
+		match value {
+			Val::Func(a) => Ok(a),
+			_ => unreachable!(),
+		}
+	}
+}
+impl TryFrom<Cc<FuncVal>> for Val {
+	type Error = LocError;
+
+	fn try_from(value: Cc<FuncVal>) -> Result<Self> {
+		Ok(Self::Func(value))
+	}
+}
+impl Typed for ObjValue {
+	const TYPE: &'static ComplexValType = &ComplexValType::Simple(ValType::Obj);
+}
+impl TryFrom<Val> for ObjValue {
+	type Error = LocError;
+
+	fn try_from(value: Val) -> Result<Self> {
+		<Self as Typed>::TYPE.check(&value)?;
+		match value {
+			Val::Obj(a) => Ok(a),
+			_ => unreachable!(),
+		}
+	}
+}
+impl TryFrom<ObjValue> for Val {
+	type Error = LocError;
+
+	fn try_from(value: ObjValue) -> Result<Self> {
+		Ok(Self::Obj(value))
+	}
+}
+
+impl Typed for bool {
+	const TYPE: &'static ComplexValType = &ComplexValType::Simple(ValType::Bool);
+}
+impl TryFrom<Val> for bool {
+	type Error = LocError;
+
+	fn try_from(value: Val) -> Result<Self> {
+		<Self as Typed>::TYPE.check(&value)?;
+		match value {
+			Val::Bool(a) => Ok(a),
+			_ => unreachable!(),
+		}
+	}
+}
+impl TryFrom<bool> for Val {
+	type Error = LocError;
+
+	fn try_from(value: bool) -> Result<Self> {
+		Ok(Self::Bool(value))
+	}
+}
+
+impl Typed for IndexableVal {
+	const TYPE: &'static ComplexValType = &ComplexValType::UnionRef(&[
+		&ComplexValType::Simple(ValType::Arr),
+		&ComplexValType::Simple(ValType::Str),
+	]);
+}
+impl TryFrom<Val> for IndexableVal {
+	type Error = LocError;
+
+	fn try_from(value: Val) -> Result<Self> {
+		<Self as Typed>::TYPE.check(&value)?;
+		value.into_indexable()
+	}
+}
+impl TryFrom<IndexableVal> for Val {
+	type Error = LocError;
+
+	fn try_from(value: IndexableVal) -> Result<Self> {
+		match value {
+			IndexableVal::Str(s) => Ok(Self::Str(s)),
+			IndexableVal::Arr(a) => Ok(Self::Arr(a)),
+		}
+	}
+}
+
+pub struct Null;
+impl Typed for Null {
+	const TYPE: &'static ComplexValType = &ComplexValType::Simple(ValType::Null);
+}
+impl TryFrom<Val> for Null {
+	type Error = LocError;
+
+	fn try_from(value: Val) -> Result<Self> {
+		<Self as Typed>::TYPE.check(&value)?;
+		Ok(Self)
+	}
+}
+impl TryFrom<Null> for Val {
+	type Error = LocError;
+
+	fn try_from(_: Null) -> Result<Self> {
+		Ok(Self::Null)
+	}
+}

--- /dev/null
+++ b/crates/jrsonnet-evaluator/src/typed/mod.rs
@@ -0,0 +1,268 @@
+use std::{fmt::Display, rc::Rc};
+
+mod conversions;
+pub use conversions::*;
+
+use crate::{
+	error::{Error, LocError, Result},
+	push_description_frame, Val,
+};
+use gcmodule::Trace;
+use jrsonnet_types::{ComplexValType, ValType};
+use thiserror::Error;
+
+#[macro_export]
+macro_rules! unwrap_type {
+	($desc: expr, $value: expr, $typ: expr => $match: path) => {{
+		use $crate::{push_stack_frame, typed::CheckType};
+		push_stack_frame(None, $desc, || Ok($typ.check(&$value)?))?;
+		match $value {
+			$match(v) => v,
+			_ => unreachable!(),
+		}
+	}};
+}
+
+#[derive(Debug, Error, Clone, Trace)]
+pub enum TypeError {
+	#[error("expected {0}, got {1}")]
+	ExpectedGot(ComplexValType, ValType),
+	#[error("missing property {0} from {1:?}")]
+	MissingProperty(#[skip_trace] Rc<str>, ComplexValType),
+	#[error("every failed from {0}:\n{1}")]
+	UnionFailed(ComplexValType, TypeLocErrorList),
+	#[error(
+		"number out of bounds: {0} not in {}..{}",
+		.1.map(|v|v.to_string()).unwrap_or_else(|| "".to_owned()),
+		.2.map(|v|v.to_string()).unwrap_or_else(|| "".to_owned()),
+	)]
+	BoundsFailed(f64, Option<f64>, Option<f64>),
+}
+impl From<TypeError> for LocError {
+	fn from(e: TypeError) -> Self {
+		Error::TypeError(e.into()).into()
+	}
+}
+
+#[derive(Debug, Clone, Trace)]
+pub struct TypeLocError(Box<TypeError>, ValuePathStack);
+impl From<TypeError> for TypeLocError {
+	fn from(e: TypeError) -> Self {
+		Self(Box::new(e), ValuePathStack(Vec::new()))
+	}
+}
+impl From<TypeLocError> for LocError {
+	fn from(e: TypeLocError) -> Self {
+		Error::TypeError(e).into()
+	}
+}
+impl Display for TypeLocError {
+	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+		write!(f, "{}", self.0)?;
+		if !(self.1).0.is_empty() {
+			write!(f, " at {}", self.1)?;
+		}
+		Ok(())
+	}
+}
+
+#[derive(Debug, Clone, Trace)]
+pub struct TypeLocErrorList(Vec<TypeLocError>);
+impl Display for TypeLocErrorList {
+	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+		use std::fmt::Write;
+		let mut out = String::new();
+		for (i, err) in self.0.iter().enumerate() {
+			if i != 0 {
+				writeln!(f)?;
+			}
+			out.clear();
+			write!(out, "{}", err)?;
+
+			for (i, line) in out.lines().enumerate() {
+				if line.trim().is_empty() {
+					continue;
+				}
+				if i != 0 {
+					writeln!(f)?;
+					write!(f, "    ")?;
+				} else {
+					write!(f, "  - ")?;
+				}
+				write!(f, "{}", line)?;
+			}
+		}
+		Ok(())
+	}
+}
+
+fn push_type_description(
+	error_reason: impl Fn() -> String,
+	path: impl Fn() -> ValuePathItem,
+	item: impl Fn() -> Result<()>,
+) -> Result<()> {
+	push_description_frame(error_reason, || match item() {
+		Ok(_) => Ok(()),
+		Err(mut e) => {
+			if let Error::TypeError(e) = &mut e.error_mut() {
+				(e.1).0.push(path())
+			}
+			Err(e)
+		}
+	})
+}
+
+// TODO: check_fast for fast path of union type checking
+pub trait CheckType {
+	fn check(&self, value: &Val) -> Result<()>;
+}
+
+impl CheckType for ValType {
+	fn check(&self, value: &Val) -> Result<()> {
+		let got = value.value_type();
+		if got != *self {
+			let loc_error: TypeLocError = TypeError::ExpectedGot((*self).into(), got).into();
+			return Err(loc_error.into());
+		}
+		Ok(())
+	}
+}
+
+#[derive(Clone, Debug, Trace)]
+enum ValuePathItem {
+	Field(#[skip_trace] Rc<str>),
+	Index(u64),
+}
+impl Display for ValuePathItem {
+	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+		match self {
+			Self::Field(name) => write!(f, ".{}", name)?,
+			Self::Index(idx) => write!(f, "[{}]", idx)?,
+		}
+		Ok(())
+	}
+}
+
+#[derive(Clone, Debug, Trace)]
+struct ValuePathStack(Vec<ValuePathItem>);
+impl Display for ValuePathStack {
+	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+		write!(f, "self")?;
+		for elem in self.0.iter().rev() {
+			write!(f, "{}", elem)?;
+		}
+		Ok(())
+	}
+}
+
+impl CheckType for ComplexValType {
+	fn check(&self, value: &Val) -> Result<()> {
+		match self {
+			Self::Any => Ok(()),
+			Self::Simple(s) => s.check(value),
+			Self::Char => match value {
+				Val::Str(s) if s.len() == 1 || s.chars().count() == 1 => Ok(()),
+				v => Err(TypeError::ExpectedGot(self.clone(), v.value_type()).into()),
+			},
+			Self::BoundedNumber(from, to) => {
+				if let Val::Num(n) = value {
+					if from.map(|from| from > *n).unwrap_or(false)
+						|| to.map(|to| to < *n).unwrap_or(false)
+					{
+						return Err(TypeError::BoundsFailed(*n, *from, *to).into());
+					}
+					Ok(())
+				} else {
+					Err(TypeError::ExpectedGot(self.clone(), value.value_type()).into())
+				}
+			}
+			Self::Array(elem_type) => match value {
+				Val::Arr(a) => {
+					for (i, item) in a.iter().enumerate() {
+						push_type_description(
+							|| format!("array index {}", i),
+							|| ValuePathItem::Index(i as u64),
+							|| elem_type.check(&item.clone()?),
+						)?;
+					}
+					Ok(())
+				}
+				v => Err(TypeError::ExpectedGot(self.clone(), v.value_type()).into()),
+			},
+			Self::ArrayRef(elem_type) => match value {
+				Val::Arr(a) => {
+					for (i, item) in a.iter().enumerate() {
+						push_type_description(
+							|| format!("array index {}", i),
+							|| ValuePathItem::Index(i as u64),
+							|| elem_type.check(&item.clone()?),
+						)?;
+					}
+					Ok(())
+				}
+				v => Err(TypeError::ExpectedGot(self.clone(), v.value_type()).into()),
+			},
+			Self::ObjectRef(elems) => match value {
+				Val::Obj(obj) => {
+					for (k, v) in elems.iter() {
+						if let Some(got_v) = obj.get((*k).into())? {
+							push_type_description(
+								|| format!("property {}", k),
+								|| ValuePathItem::Field((*k).into()),
+								|| v.check(&got_v),
+							)?
+						} else {
+							return Err(
+								TypeError::MissingProperty((*k).into(), self.clone()).into()
+							);
+						}
+					}
+					Ok(())
+				}
+				v => Err(TypeError::ExpectedGot(self.clone(), v.value_type()).into()),
+			},
+			Self::Union(types) => {
+				let mut errors = Vec::new();
+				for ty in types.iter() {
+					match ty.check(value) {
+						Ok(()) => {
+							return Ok(());
+						}
+						Err(e) => match e.error() {
+							Error::TypeError(e) => errors.push(e.clone()),
+							_ => return Err(e),
+						},
+					}
+				}
+				Err(TypeError::UnionFailed(self.clone(), TypeLocErrorList(errors)).into())
+			}
+			Self::UnionRef(types) => {
+				let mut errors = Vec::new();
+				for ty in types.iter() {
+					match ty.check(value) {
+						Ok(()) => {
+							return Ok(());
+						}
+						Err(e) => match e.error() {
+							Error::TypeError(e) => errors.push(e.clone()),
+							_ => return Err(e),
+						},
+					}
+				}
+				Err(TypeError::UnionFailed(self.clone(), TypeLocErrorList(errors)).into())
+			}
+			Self::Sum(types) => {
+				for ty in types.iter() {
+					ty.check(value)?
+				}
+				Ok(())
+			}
+			Self::SumRef(types) => {
+				for ty in types.iter() {
+					ty.check(value)?
+				}
+				Ok(())
+			}
+		}
+	}
+}

--- /dev/null
+++ b/crates/jrsonnet-macros/Cargo.toml
@@ -0,0 +1,12 @@
+[package]
+name = "jrsonnet-macros"
+version = "0.4.2"
+edition = "2021"
+
+[lib]
+proc-macro = true
+
+[dependencies]
+proc-macro2 = "1.0.32"
+quote = "1.0.10"
+syn = { version = "1.0.82", features = ["full"] }

--- /dev/null
+++ b/crates/jrsonnet-macros/src/lib.rs
@@ -0,0 +1,87 @@
+use proc_macro2::Span;
+use quote::quote;
+use syn::{parse_macro_input, FnArg, Ident, ItemFn, Pat};
+
+#[proc_macro_attribute]
+pub fn builtin(
+	_attr: proc_macro::TokenStream,
+	item: proc_macro::TokenStream,
+) -> proc_macro::TokenStream {
+	// syn::ItemFn::parse(input)
+	let fun: ItemFn = parse_macro_input!(item);
+
+	let inner_name = Ident::new("inner", Span::call_site());
+	let mut inner_fun = fun.clone();
+	inner_fun.sig.ident = inner_name.clone();
+	let result = match fun.sig.output {
+		syn::ReturnType::Default => panic!("builtin should return something"),
+		syn::ReturnType::Type(_, ty) => ty,
+	};
+
+	let params = fun
+		.sig
+		.inputs
+		.iter()
+		.map(|i| match i {
+			FnArg::Receiver(_) => unreachable!(),
+			FnArg::Typed(t) => t,
+		})
+		.map(|t| {
+			let ident = match &t.pat as &Pat {
+				Pat::Ident(i) => i.ident.to_string(),
+				_ => panic!("only idents supported yet"),
+			};
+			// TODO: Check if ty == Option<_>
+			let optional = false;
+			quote! {
+				BuiltinParam {
+					name: #ident,
+					has_default: #optional,
+				}
+			}
+		});
+
+	let args = fun
+		.sig
+		.inputs
+		.iter()
+		.map(|i| match i {
+			FnArg::Receiver(_) => unreachable!(),
+			FnArg::Typed(t) => t,
+		})
+		.map(|t| {
+			let ident = match &t.pat as &Pat {
+				Pat::Ident(i) => i.ident.to_string(),
+				_ => panic!("only idents supported yet"),
+			};
+			let ty = &t.ty;
+			quote! {{
+				let value = parsed.get(#ident).unwrap();
+
+				jrsonnet_evaluator::push_description_frame(
+					|| format!("argument <{}> evaluation", #ident),
+					|| <#ty>::try_from(value.evaluate()?),
+				)?
+			}}
+		});
+
+	let attrs = &fun.attrs;
+	let vis = &fun.vis;
+	let name = &fun.sig.ident;
+	(quote! {
+		#(#attrs)*
+		#vis fn #name(context: Context, _loc: &ExprLocation, args: &ArgsDesc) -> Result<Val> {
+			#inner_fun
+			use jrsonnet_evaluator::function::BuiltinParam;
+			const PARAMS: &'static [BuiltinParam] = &[
+				#(#params),*
+			];
+			let parsed = jrsonnet_evaluator::function::parse_builtin_call(context, &PARAMS, args, false)?;
+
+			let result: #result = #inner_name(#(#args),*);
+			let result = result?;
+			result.try_into()
+		}
+	})
+	.into()
+}