git.delta.rocks / jrsonnet / refs/commits / 0f5b614a0779

9use self::{9use self::{
10	builtin::Builtin,10	builtin::Builtin,
11	parse::{parse_builtin_call, parse_default_function_call, parse_function_call},11	parse::{parse_builtin_call, parse_default_function_call, parse_function_call},
12	prepared::{parse_prepared_builtin_call, parse_prepared_function_call, PreparedCall},12	prepared::{PreparedCall, parse_prepared_builtin_call, parse_prepared_function_call},
13};13};
14use crate::{14use crate::{
15	bail, error::ErrorKind::*, evaluate, evaluate_trivial, function::builtin::BuiltinFunc, Context,15	Context, Result, Thunk, Val, evaluate, evaluate_trivial, function::builtin::BuiltinFunc,
16	Result, Thunk, Val,
17};16};
1817
19pub mod builtin;18pub mod builtin;
99pub enum FuncVal {98pub enum FuncVal {
100	/// Plain function implemented in jsonnet.99	/// Plain function implemented in jsonnet.
101	Normal(Cc<FuncDesc>),100	Normal(Cc<FuncDesc>),
102	/// Function without arguments works just as a fancy thunk value.
103	Thunk(Thunk<Val>),
104	/// User-provided function.101	/// User-provided function.
105	Builtin(BuiltinFunc),102	Builtin(BuiltinFunc),
106}103}
107104
108impl Debug for FuncVal {105impl Debug for FuncVal {
109	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {106	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
110		match self {107		match self {
111			Self::Thunk(arg0) => f.debug_tuple("Thunk").field(arg0).finish(),
112			Self::Normal(arg0) => f.debug_tuple("Normal").field(arg0).finish(),108			Self::Normal(arg0) => f.debug_tuple("Normal").field(arg0).finish(),
113			Self::Builtin(arg0) => f.debug_tuple("Builtin").field(&arg0.name()).finish(),109			Self::Builtin(arg0) => f.debug_tuple("Builtin").field(&arg0.name()).finish(),
114		}110		}
130		match self {126		match self {
131			Self::Builtin(i) => i.params(),127			Self::Builtin(i) => i.params(),
132			Self::Normal(p) => p.params.signature.clone(),128			Self::Normal(p) => p.params.signature.clone(),
133			Self::Thunk(_) => FunctionSignature::empty(),
134		}129		}
135	}130	}
136	/// Amount of non-default required arguments131	/// Amount of non-default required arguments
142		match self {137		match self {
143			Self::Normal(normal) => normal.name.clone(),138			Self::Normal(normal) => normal.name.clone(),
144			Self::Builtin(builtin) => builtin.name().into(),139			Self::Builtin(builtin) => builtin.name().into(),
145			Self::Thunk(_) => "thunk".into(),
146		}140		}
147	}141	}
148	/// Call function using arguments evaluated in specified `call_ctx` [`Context`].142	/// Call function using arguments evaluated in specified `call_ctx` [`Context`].
160				let body_ctx = func.call_body_context(call_ctx, args, tailstrict)?;154				let body_ctx = func.call_body_context(call_ctx, args, tailstrict)?;
161				evaluate(body_ctx, &func.body)155				evaluate(body_ctx, &func.body)
162			}156			}
163			Self::Thunk(thunk) => {
164				if !args.named.is_empty() || !args.unnamed.is_empty() {
165					bail!(TooManyArgsFunctionHas(0, FunctionSignature::empty()))
166				}
167				thunk.evaluate()
168			}
169			Self::Builtin(b) => {157			Self::Builtin(b) => {
170				let args = parse_builtin_call(call_ctx, b.params(), args, tailstrict)?;158				let args = parse_builtin_call(call_ctx, b.params(), args, tailstrict)?;
171				b.call(loc, &args)159				b.call(loc, &args)
192				)?;180				)?;
193				evaluate(body_ctx, &func.body)181				evaluate(body_ctx, &func.body)
194			}182			}
195			FuncVal::Thunk(t) => t.evaluate(),
196			FuncVal::Builtin(b) => {183			FuncVal::Builtin(b) => {
197				let args = parse_prepared_builtin_call(prepared, b.params(), unnamed, named);184				let args = parse_prepared_builtin_call(prepared, b.params(), unnamed, named);
198				b.call(loc, &args)185				b.call(loc, &args)
225				};212				};
226				matches!(&*desc.body, Expr::Var(v) if &**v == id)213				matches!(&*desc.body, Expr::Var(v) if &**v == id)
227			}214			}
228			Self::Thunk(_) => false,
229		}215		}
230	}216	}
231217
232	pub fn evaluate_trivial(&self) -> Option<Val> {218	pub fn evaluate_trivial(&self) -> Option<Val> {
233		match self {219		match self {
234			Self::Normal(n) => n.evaluate_trivial(),220			Self::Normal(n) => n.evaluate_trivial(),
235			_ => None,221			Self::Builtin(_) => None,
236		}222		}
237	}223	}
238}224}

1use proc_macro2::TokenStream;1use proc_macro2::TokenStream;
2use quote::quote;2use quote::quote;
3use syn::{3use syn::{
4	parenthesized,4	DeriveInput, Error, Ident, LitStr, Result, Token, Type, parenthesized,
5	parse::{Parse, ParseStream},5	parse::{Parse, ParseStream},
6	spanned::Spanned as _,6	spanned::Spanned as _,
7	token, DeriveInput, Error, Ident, LitStr, Result, Token, Type,7	token,
8};8};
99
10use crate::{extract_type_from_option, kw, names::Names, parse_attr, type_is_path};10use crate::{extract_type_from_option, kw, names::Names, parse_attr, type_is_path};

12pub use encoding::*;12pub use encoding::*;
13pub use hash::*;13pub use hash::*;
14use jrsonnet_evaluator::{14use jrsonnet_evaluator::{
15	ContextBuilder, IStr, ObjValue, ObjValueBuilder, Thunk, Val,
15	error::Result,16	error::Result,
16	function::{builtin_id, CallLocation, FuncVal},17	function::{CallLocation, FuncVal, builtin_id},
17	tla::TlaArg,18	tla::TlaArg,
18	trace::PathResolver,19	trace::PathResolver,
19	typed::SerializeTypedObj as _,20	typed::SerializeTypedObj as _,
20	val::NumValue,21	val::NumValue,
21	ContextBuilder, IStr, ObjValue, ObjValueBuilder, Thunk, Val,
22};22};
23use jrsonnet_gcmodule::{Acyclic, Cc, Trace};23use jrsonnet_gcmodule::{Acyclic, Cc, Trace};
24use jrsonnet_ir::Source;24use jrsonnet_ir::Source;