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

172 "jrsonnet-stdlib",172 "jrsonnet-stdlib",
173 "md5",173 "md5",
174 "pathdiff",174 "pathdiff",
175 "rustc-hash",
175 "serde",176 "serde",
176 "serde_json",177 "serde_json",
177 "structdump",178 "structdump",
321 "proc-macro2",322 "proc-macro2",
322]323]
324
325[[package]]
326name = "rustc-hash"
327version = "1.1.0"
328source = "registry+https://github.com/rust-lang/crates.io-index"
329checksum = "08d43f7aa6b08d49f382cde6a7982047c3426db949b1424bc4b7ec9ae12c6ce2"
323330
324[[package]]331[[package]]
325name = "ryu"332name = "ryu"

9# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html9# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
1010
11[features]11[features]
12default = ["serialized-stdlib", "faster", "explaining-traces"]12default = ["serialized-stdlib", "faster", "explaining-traces", "serde-json"]
13# Serializes standard library AST instead of parsing them every run13# Serializes standard library AST instead of parsing them every run
14serialized-stdlib = ["serde", "bincode", "jrsonnet-parser/deserialize"]14serialized-stdlib = ["serde", "bincode", "jrsonnet-parser/deserialize"]
15# Allow to convert Val into serde_json::Value and backwards15# Allow to convert Val into serde_json::Value and backwards
3535
36md5 = "0.7.0"36md5 = "0.7.0"
37base64 = "0.12.3"37base64 = "0.12.3"
38rustc-hash = "1.1.0"
3839
39# Serialized stdlib40# Serialized stdlib
40[dependencies.serde]41[dependencies.serde]

158		("std", "native") => parse_args!(context, "std.native", args, 1, [158		("std", "native") => parse_args!(context, "std.native", args, 1, [
159			0, x: [Val::Str]!!Val::Str, vec![ValType::Str];159			0, x: [Val::Str]!!Val::Str, vec![ValType::Str];
160		], {160		], {
161			Ok(with_state(|s| s.settings().ext_natives.get(&x).cloned()).map(|v| Val::Func(FuncVal::NativeExt(x.clone(), v))).ok_or_else(161			Ok(with_state(|s| s.settings().ext_natives.get(&x).cloned()).map(|v| Val::Func(Rc::new(FuncVal::NativeExt(x.clone(), v)))).ok_or_else(
162				|| UndefinedExternalFunction(x),162				|| UndefinedExternalFunction(x),
163			)?)163			)?)
164		})?,164		})?,
212			if arr.len() <= 1 {212			if arr.len() <= 1 {
213				return Ok(Val::Arr(arr))213				return Ok(Val::Arr(arr))
214			}214			}
215			Ok(Val::Arr(sort::sort(context, arr, keyF)?))215			Ok(Val::Arr(sort::sort(context, arr, &keyF)?))
216		})?,216		})?,
217		// faster217		// faster
218		("std", "format") => parse_args!(context, "std.format", args, 2, [218		("std", "format") => parse_args!(context, "std.format", args, 2, [

2	error::Error::*, future_wrapper, map::LayeredHashMap, rc_fn_helper, resolved_lazy_val,2	error::Error::*, future_wrapper, map::LayeredHashMap, rc_fn_helper, resolved_lazy_val,
3	LazyBinding, LazyVal, ObjValue, Result, Val,3	LazyBinding, LazyVal, ObjValue, Result, Val,
4};4};
5use rustc_hash::FxHashMap;
6use std::hash::BuildHasherDefault;
5use std::{cell::RefCell, collections::HashMap, fmt::Debug, rc::Rc};7use std::{cell::RefCell, collections::HashMap, fmt::Debug, rc::Rc};
68
7rc_fn_helper!(9rc_fn_helper!(
71	}73	}
7274
73	pub fn with_var(self, name: Rc<str>, value: Val) -> Context {75	pub fn with_var(self, name: Rc<str>, value: Val) -> Context {
74		let mut new_bindings = HashMap::with_capacity(1);76		let mut new_bindings =
77			FxHashMap::with_capacity_and_hasher(1, BuildHasherDefault::default());
75		new_bindings.insert(name, resolved_lazy_val!(value));78		new_bindings.insert(name, resolved_lazy_val!(value));
76		self.extend(new_bindings, None, None, None)79		self.extend(new_bindings, None, None, None)
77	}80	}
7881
79	pub fn extend(82	pub fn extend(
80		self,83		self,
81		new_bindings: HashMap<Rc<str>, LazyVal>,84		new_bindings: FxHashMap<Rc<str>, LazyVal>,
82		new_dollar: Option<ObjValue>,85		new_dollar: Option<ObjValue>,
83		new_this: Option<ObjValue>,86		new_this: Option<ObjValue>,
84		new_super_obj: Option<ObjValue>,87		new_super_obj: Option<ObjValue>,
127	) -> Result<Context> {130	) -> Result<Context> {
128		let this = new_this.or_else(|| self.0.this.clone());131		let this = new_this.or_else(|| self.0.this.clone());
129		let super_obj = new_super_obj.or_else(|| self.0.super_obj.clone());132		let super_obj = new_super_obj.or_else(|| self.0.super_obj.clone());
130		let mut new = HashMap::with_capacity(new_bindings.len());133		let mut new =
134			FxHashMap::with_capacity_and_hasher(new_bindings.len(), BuildHasherDefault::default());
131		for (k, v) in new_bindings.into_iter() {135		for (k, v) in new_bindings.into_iter() {
132			new.insert(k, v.evaluate(this.clone(), super_obj.clone())?);136			new.insert(k, v.evaluate(this.clone(), super_obj.clone())?);
133		}137		}

9	ForSpecData, IfSpecData, LiteralType, LocExpr, Member, ObjBody, ParamsDesc, UnaryOpType,9	ForSpecData, IfSpecData, LiteralType, LocExpr, Member, ObjBody, ParamsDesc, UnaryOpType,
10	Visibility,10	Visibility,
11};11};
12use rustc_hash::FxHashMap;
12use std::{collections::HashMap, rc::Rc};13use std::{collections::HashMap, rc::Rc};
1314
14pub fn evaluate_binding(b: &BindSpec, context_creator: ContextCreator) -> (Rc<str>, LazyBinding) {15pub fn evaluate_binding(b: &BindSpec, context_creator: ContextCreator) -> (Rc<str>, LazyBinding) {
45}46}
4647
47pub fn evaluate_method(ctx: Context, name: Rc<str>, params: ParamsDesc, body: LocExpr) -> Val {48pub fn evaluate_method(ctx: Context, name: Rc<str>, params: ParamsDesc, body: LocExpr) -> Val {
48	Val::Func(FuncVal::Normal(Rc::new(FuncDesc {49	Val::Func(Rc::new(FuncVal::Normal(FuncDesc {
49		name,50		name,
50		ctx,51		ctx,
51		params,52		params,
351					let key = evaluate(ctx.clone(), &obj.key)?;352					let key = evaluate(ctx.clone(), &obj.key)?;
352					let value = LazyBinding::Bindable(Rc::new(353					let value = LazyBinding::Bindable(Rc::new(
353						closure!(clone ctx, clone obj.value, |this, _super_obj| {354						closure!(clone ctx, clone obj.value, |this, _super_obj| {
354							Ok(LazyVal::new_resolved(evaluate(ctx.clone().extend(HashMap::new(), None, this, None), &value)?))355							Ok(LazyVal::new_resolved(evaluate(ctx.clone().extend(FxHashMap::default(), None, this, None), &value)?))
355						}),356						}),
356					));357					));
357358
468							} else if let Some(Val::Str(n)) =469							} else if let Some(Val::Str(n)) =
469								v.get("__intristic_namespace__".into())?470								v.get("__intristic_namespace__".into())?
470							{471							{
471								Ok(Val::Func(FuncVal::Intristic(n, s)))472								Ok(Val::Func(Rc::new(FuncVal::Intristic(n, s))))
472							} else {473							} else {
473								throw!(NoSuchField(s))474								throw!(NoSuchField(s))
474							}475							}

1use crate::{error::Error::*, evaluate, lazy_val, resolved_lazy_val, throw, Context, Result, Val};1use crate::{error::Error::*, evaluate, lazy_val, resolved_lazy_val, throw, Context, Result, Val};
2use closure::closure;2use closure::closure;
3use jrsonnet_parser::{ArgsDesc, ParamsDesc};3use jrsonnet_parser::{ArgsDesc, ParamsDesc};
4use rustc_hash::FxHashMap;
4use std::{collections::HashMap, rc::Rc};5use std::{collections::HashMap, hash::BuildHasherDefault, rc::Rc};
56
6const NO_DEFAULT_CONTEXT: &str =7const NO_DEFAULT_CONTEXT: &str =
7	"no default context set for call with defined default parameter value";8	"no default context set for call with defined default parameter value";
20	args: &ArgsDesc,21	args: &ArgsDesc,
21	tailstrict: bool,22	tailstrict: bool,
22) -> Result<Context> {23) -> Result<Context> {
23	let mut out = HashMap::with_capacity(params.len());24	let mut out = HashMap::with_capacity_and_hasher(params.len(), BuildHasherDefault::default());
24	let mut positioned_args = vec![None; params.0.len()];25	let mut positioned_args = vec![None; params.0.len()];
25	for (id, arg) in args.iter().enumerate() {26	for (id, arg) in args.iter().enumerate() {
26		let idx = if let Some(name) = &arg.0 {27		let idx = if let Some(name) = &arg.0 {
67	args: &HashMap<Rc<str>, Val>,68	args: &HashMap<Rc<str>, Val>,
68	tailstrict: bool,69	tailstrict: bool,
69) -> Result<Context> {70) -> Result<Context> {
70	let mut out = HashMap::with_capacity(params.len());71	let mut out = FxHashMap::with_capacity_and_hasher(params.len(), BuildHasherDefault::default());
71	let mut positioned_args = vec![None; params.0.len()];72	let mut positioned_args = vec![None; params.0.len()];
72	for (name, val) in args.iter() {73	for (name, val) in args.iter() {
73		let idx = params74		let idx = params
115	params: &ParamsDesc,116	params: &ParamsDesc,
116	args: &[Val],117	args: &[Val],
117) -> Result<Context> {118) -> Result<Context> {
118	let mut out = HashMap::with_capacity(params.len());119	let mut out = FxHashMap::with_capacity_and_hasher(params.len(), BuildHasherDefault::default());
119	let mut positioned_args = vec![None; params.0.len()];120	let mut positioned_args = vec![None; params.0.len()];
120	for (id, arg) in args.iter().enumerate() {121	for (id, arg) in args.iter().enumerate() {
121		if id >= params.len() {122		if id >= params.len() {

1use rustc_hash::FxHashMap;
1use std::{borrow::Borrow, collections::HashMap, hash::Hash, rc::Rc};2use std::{borrow::Borrow, hash::Hash, rc::Rc};
23
3#[derive(Default, Debug)]4#[derive(Default, Debug)]
4struct LayeredHashMapInternals<K: Hash, V> {5struct LayeredHashMapInternals<K: Hash, V> {
5	parent: Option<LayeredHashMap<K, V>>,6	parent: Option<LayeredHashMap<K, V>>,
6	current: HashMap<K, V>,7	current: FxHashMap<K, V>,
7}8}
89
9#[derive(Debug)]10#[derive(Debug)]
10pub struct LayeredHashMap<K: Hash, V>(Rc<LayeredHashMapInternals<K, V>>);11pub struct LayeredHashMap<K: Hash, V>(Rc<LayeredHashMapInternals<K, V>>);
1112
12impl<K: Hash + Eq, V> LayeredHashMap<K, V> {13impl<K: Hash + Eq, V> LayeredHashMap<K, V> {
13	pub fn extend(self, new_layer: HashMap<K, V>) -> Self {14	pub fn extend(self, new_layer: FxHashMap<K, V>) -> Self {
14		match Rc::try_unwrap(self.0) {15		match Rc::try_unwrap(self.0) {
15			Ok(mut map) => {16			Ok(mut map) => {
16				map.current.extend(new_layer);17				map.current.extend(new_layer);
45	fn default() -> Self {46	fn default() -> Self {
46		LayeredHashMap(Rc::new(LayeredHashMapInternals {47		LayeredHashMap(Rc::new(LayeredHashMapInternals {
47			parent: None,48			parent: None,
48			current: HashMap::new(),49			current: FxHashMap::default(),
49		}))50		}))
50	}51	}
51}52}

71	pub body: LocExpr,71	pub body: LocExpr,
72}72}
7373
74#[derive(Debug, Clone)]74#[derive(Debug)]
75pub enum FuncVal {75pub enum FuncVal {
76	/// Plain function implemented in jsonnet76	/// Plain function implemented in jsonnet
77	Normal(Rc<FuncDesc>),77	Normal(FuncDesc),
78	/// Standard library function78	/// Standard library function
79	Intristic(Rc<str>, Rc<str>),79	Intristic(Rc<str>, Rc<str>),
80	/// Library functions implemented in native80	/// Library functions implemented in native
212	Lazy(LazyVal),213	Lazy(LazyVal),
213	Arr(Rc<Vec<Val>>),214	Arr(Rc<Vec<Val>>),
214	Obj(ObjValue),215	Obj(ObjValue),
215	Func(FuncVal),216	Func(Rc<FuncVal>),
216}217}
218
217macro_rules! matches_unwrap {219macro_rules! matches_unwrap {