git.delta.rocks / jrsonnet / refs/commits / 695a2f8d51fa

5edition = "2018"5edition = "2018"
66
7[dependencies]7[dependencies]
8jrsonnet-interner = { path = "../../crates/jrsonnet-interner", version = "0.3.3" }
8jrsonnet-evaluator = { path = "../../crates/jrsonnet-evaluator", version = "0.3.3" }9jrsonnet-evaluator = { path = "../../crates/jrsonnet-evaluator", version = "0.3.3" }
9jrsonnet-parser = { path = "../../crates/jrsonnet-parser", version = "0.3.3" }10jrsonnet-parser = { path = "../../crates/jrsonnet-parser", version = "0.3.3" }
1011

4	error::{Error::*, Result},4	error::{Error::*, Result},
5	throw, EvaluationState, ImportResolver,5	throw, EvaluationState, ImportResolver,
6};6};
7use jrsonnet_interner::IStr;
7use std::{8use std::{
8	any::Any,9	any::Any,
9	cell::RefCell,10	cell::RefCell,
30	cb: JsonnetImportCallback,31	cb: JsonnetImportCallback,
31	ctx: *mut c_void,32	ctx: *mut c_void,
3233
33	out: RefCell<HashMap<PathBuf, Rc<str>>>,34	out: RefCell<HashMap<PathBuf, IStr>>,
34}35}
35impl ImportResolver for CallbackImportResolver {36impl ImportResolver for CallbackImportResolver {
36	fn resolve_file(&self, from: &PathBuf, path: &PathBuf) -> Result<Rc<PathBuf>> {37	fn resolve_file(&self, from: &PathBuf, path: &PathBuf) -> Result<Rc<PathBuf>> {
7576
76		Ok(Rc::new(found_here_buf))77		Ok(Rc::new(found_here_buf))
77	}78	}
78	fn load_file_contents(&self, resolved: &PathBuf) -> Result<Rc<str>> {79	fn load_file_contents(&self, resolved: &PathBuf) -> Result<IStr> {
79		Ok(self.out.borrow().get(resolved).unwrap().clone())80		Ok(self.out.borrow().get(resolved).unwrap().clone())
80	}81	}
81	unsafe fn as_any(&self) -> &dyn Any {82	unsafe fn as_any(&self) -> &dyn Any {
124			throw!(ImportFileNotFound(from.clone(), path.clone()))125			throw!(ImportFileNotFound(from.clone(), path.clone()))
125		}126		}
126	}127	}
127	fn load_file_contents(&self, id: &PathBuf) -> Result<Rc<str>> {128	fn load_file_contents(&self, id: &PathBuf) -> Result<IStr> {
128		let mut file = File::open(id).map_err(|_e| ResolvedFileNotFound(id.clone()))?;129		let mut file = File::open(id).map_err(|_e| ResolvedFileNotFound(id.clone()))?;
129		let mut out = String::new();130		let mut out = String::new();
130		file.read_to_string(&mut out)131		file.read_to_string(&mut out)

88
9use import::NativeImportResolver;9use import::NativeImportResolver;
10use jrsonnet_evaluator::{EvaluationState, ManifestFormat, Val};10use jrsonnet_evaluator::{EvaluationState, ManifestFormat, Val};
11use jrsonnet_interner::IStr;
11use std::{12use std::{
12	alloc::Layout,13	alloc::Layout,
13	ffi::{CStr, CString},14	ffi::{CStr, CString},
161	})162	})
162}163}
163164
164fn multi_to_raw(multi: Vec<(Rc<str>, Rc<str>)>) -> *const c_char {165fn multi_to_raw(multi: Vec<(IStr, IStr)>) -> *const c_char {
165	let mut out = Vec::new();166	let mut out = Vec::new();
166	for (i, (k, v)) in multi.iter().enumerate() {167	for (i, (k, v)) in multi.iter().enumerate() {
167		if i != 0 {168		if i != 0 {
237	})238	})
238}239}
239240
240fn stream_to_raw(multi: Vec<Rc<str>>) -> *const c_char {241fn stream_to_raw(multi: Vec<IStr>) -> *const c_char {
241	let mut out = Vec::new();242	let mut out = Vec::new();
242	for (i, v) in multi.iter().enumerate() {243	for (i, v) in multi.iter().enumerate() {
243		if i != 0 {244		if i != 0 {

12serialized-stdlib = ["serde", "bincode", "jrsonnet-parser/deserialize"]12serialized-stdlib = ["serde", "bincode", "jrsonnet-parser/deserialize"]
13# Allow to convert Val into serde_json::Value and backwards13# Allow to convert Val into serde_json::Value and backwards
14serde-json = ["serde", "serde_json"]14serde-json = ["serde", "serde_json"]
15# Same as above, but with generated code instead of serde. Reduces memory usage, but increases binary size and compilation time
16codegenerated-stdlib = []
17# Replace some standard library functions with faster implementations (I.e manifestJsonEx)15# Replace some standard library functions with faster implementations (I.e manifestJsonEx)
18# Library works fine without this feature, but requires more memory and time for std function calls16# Library works fine without this feature, but requires more memory and time for std function calls
19faster = []17faster = []
24unstable = []22unstable = []
2523
26[dependencies]24[dependencies]
25jrsonnet-interner = { path = "../jrsonnet-interner" }
27jrsonnet-parser = { path = "../jrsonnet-parser", version = "0.3.3" }26jrsonnet-parser = { path = "../jrsonnet-parser", version = "0.3.3" }
28jrsonnet-stdlib = { path = "../jrsonnet-stdlib", version = "0.3.3" }27jrsonnet-stdlib = { path = "../jrsonnet-stdlib", version = "0.3.3" }
29jrsonnet-types = { path = "../jrsonnet-types", version = "0.3.3" }28jrsonnet-types = { path = "../jrsonnet-types", version = "0.3.3" }
58optional = true57optional = true
5958
60[build-dependencies]59[build-dependencies]
61jrsonnet-parser = { path = "../jrsonnet-parser", features = ["dump", "serialize", "deserialize"], version = "0.3.3" }60jrsonnet-parser = { path = "../jrsonnet-parser", features = ["serialize", "deserialize"], version = "0.3.3" }
62jrsonnet-stdlib = { path = "../jrsonnet-stdlib", version = "0.3.3" }61jrsonnet-stdlib = { path = "../jrsonnet-stdlib", version = "0.3.3" }
63structdump = "0.1.2"
64serde = "1.0"62serde = "1.0"
65bincode = "1.3.1"63bincode = "1.3.1"
6664

10	path::{Path, PathBuf},10	path::{Path, PathBuf},
11	rc::Rc,11	rc::Rc,
12};12};
13use structdump::CodegenResult;
1413
15fn main() {14fn main() {
16	let parsed = parse(15	let parsed = parse(
36									name: FieldName::Fixed(name),35									name: FieldName::Fixed(name),
37									..36									..
38								})37								})
39								if **name == *"join" || **name == *"manifestJsonEx" ||38								if name == "join" || name == "manifestJsonEx" ||
40								**name == *"escapeStringJson" || **name == *"equals" ||39								name == "escapeStringJson" || name == "equals" ||
41								**name == *"base64" || **name == *"foldl" || **name == *"foldr" ||40								name == "base64" || name == "foldl" || name == "foldr" ||
42								**name == *"sortImpl" || **name == *"format" || **name == *"range" ||41								name == "sortImpl" || name == "format" || name == "range" ||
43								**name == *"reverse" || **name == *"slice" || **name == *"mod"42								name == "reverse" || name == "slice" || name == "mod"
44							)43							)
45						})44						})
46						.collect(),45						.collect(),
52	} else {51	} else {
53		parsed52		parsed
54	};53	};
55	{
56		let mut codegen = CodegenResult::default();
57		let code = codegen.codegen(&parsed);
58
59		let out_dir = env::var("OUT_DIR").unwrap();
60		let dest_path = Path::new(&out_dir).join("stdlib.rs");
61		let mut f = File::create(&dest_path).unwrap();
62		f.write_all(&code.as_bytes()).unwrap();
63	}
64	{54	{
65		let out_dir = env::var("OUT_DIR").unwrap();55		let out_dir = env::var("OUT_DIR").unwrap();
66		let dest_path = Path::new(&out_dir).join("stdlib.bincode");56		let dest_path = Path::new(&out_dir).join("stdlib.bincode");

2#![allow(clippy::too_many_arguments)]2#![allow(clippy::too_many_arguments)]
33
4use crate::{error::Error::*, throw, LocError, ObjValue, Result, Val};4use crate::{error::Error::*, throw, LocError, ObjValue, Result, Val};
5use jrsonnet_interner::IStr;
5use jrsonnet_types::ValType;6use jrsonnet_types::ValType;
6use thiserror::Error;7use thiserror::Error;
78
20	#[error("mapping keys required")]21	#[error("mapping keys required")]
21	MappingKeysRequired,22	MappingKeysRequired,
22	#[error("no such format field: {0}")]23	#[error("no such format field: {0}")]
23	NoSuchFormatField(Rc<str>),24	NoSuchFormatField(IStr),
24}25}
2526
26impl From<FormatError> for LocError {27impl From<FormatError> for LocError {
29	}30	}
30}31}
3132
32use std::rc::Rc;
33use FormatError::*;33use FormatError::*;
3434
35type ParseResult<'t, T> = std::result::Result<(T, &'t str), FormatError>;35type ParseResult<'t, T> = std::result::Result<(T, &'t str), FormatError>;
680			}680			}
681			Element::Code(c) => {681			Element::Code(c) => {
682				// TODO: Operate on ref682				// TODO: Operate on ref
683				let f: Rc<str> = c.mkey.into();683				let f: IStr = c.mkey.into();
684				let width = match c.width {684				let width = match c.width {
685					Width::Star => {685					Width::Star => {
686						throw!(CannotUseStarWidthWithObject);686						throw!(CannotUseStarWidthWithObject);

6	with_state, ArrValue, Context, FuncVal, LazyVal, Val,6	with_state, ArrValue, Context, FuncVal, LazyVal, Val,
7};7};
8use format::{format_arr, format_obj};8use format::{format_arr, format_obj};
9use jrsonnet_interner::IStr;
9use jrsonnet_parser::{ArgsDesc, BinaryOpType, ExprLocation};10use jrsonnet_parser::{ArgsDesc, BinaryOpType, ExprLocation};
10use jrsonnet_types::ty;11use jrsonnet_types::ty;
11use std::{collections::HashMap, path::PathBuf, rc::Rc};12use std::{collections::HashMap, path::PathBuf, rc::Rc};
19pub mod manifest;20pub mod manifest;
20pub mod sort;21pub mod sort;
2122
22fn std_format(str: Rc<str>, vals: Val) -> Result<Val> {23fn std_format(str: IStr, vals: Val) -> Result<Val> {
23	push(24	push(
24		&Some(ExprLocation(Rc::from(PathBuf::from("std.jsonnet")), 0, 0)),25		&Some(ExprLocation(Rc::from(PathBuf::from("std.jsonnet")), 0, 0)),
25		|| format!("std.format of {}", str),26		|| format!("std.format of {}", str),

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 jrsonnet_interner::IStr;
5use rustc_hash::FxHashMap;6use rustc_hash::FxHashMap;
6use std::hash::BuildHasherDefault;7use std::hash::BuildHasherDefault;
7use std::{cell::RefCell, collections::HashMap, fmt::Debug, rc::Rc};8use std::{cell::RefCell, collections::HashMap, fmt::Debug, rc::Rc};
18	dollar: Option<ObjValue>,19	dollar: Option<ObjValue>,
19	this: Option<ObjValue>,20	this: Option<ObjValue>,
20	super_obj: Option<ObjValue>,21	super_obj: Option<ObjValue>,
21	bindings: LayeredHashMap<Rc<str>, LazyVal>,22	bindings: LayeredHashMap<IStr, LazyVal>,
22}23}
23impl Debug for ContextInternals {24impl Debug for ContextInternals {
24	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {25	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
57		}))58		}))
58	}59	}
5960
60	pub fn binding(&self, name: Rc<str>) -> Result<LazyVal> {61	pub fn binding(&self, name: IStr) -> Result<LazyVal> {
61		Ok(self62		Ok(self
62			.063			.0
63			.bindings64			.bindings
72		ctx.unwrap()73		ctx.unwrap()
73	}74	}
7475
75	pub fn with_var(self, name: Rc<str>, value: Val) -> Self {76	pub fn with_var(self, name: IStr, value: Val) -> Self {
76		let mut new_bindings =77		let mut new_bindings =
77			FxHashMap::with_capacity_and_hasher(1, BuildHasherDefault::default());78			FxHashMap::with_capacity_and_hasher(1, BuildHasherDefault::default());
78		new_bindings.insert(name, resolved_lazy_val!(value));79		new_bindings.insert(name, resolved_lazy_val!(value));
8182
82	pub fn extend(83	pub fn extend(
83		self,84		self,
84		new_bindings: FxHashMap<Rc<str>, LazyVal>,85		new_bindings: FxHashMap<IStr, LazyVal>,
85		new_dollar: Option<ObjValue>,86		new_dollar: Option<ObjValue>,
86		new_this: Option<ObjValue>,87		new_this: Option<ObjValue>,
87		new_super_obj: Option<ObjValue>,88		new_super_obj: Option<ObjValue>,
123	}124	}
124	pub fn extend_unbound(125	pub fn extend_unbound(
125		self,126		self,
126		new_bindings: HashMap<Rc<str>, LazyBinding>,127		new_bindings: HashMap<IStr, LazyBinding>,
127		new_dollar: Option<ObjValue>,128		new_dollar: Option<ObjValue>,
128		new_this: Option<ObjValue>,129		new_this: Option<ObjValue>,
129		new_super_obj: Option<ObjValue>,130		new_super_obj: Option<ObjValue>,

2	builtin::{format::FormatError, sort::SortError},2	builtin::{format::FormatError, sort::SortError},
3	typed::TypeLocError,3	typed::TypeLocError,
4};4};
5use jrsonnet_interner::IStr;
5use jrsonnet_parser::{BinaryOpType, ExprLocation, UnaryOpType};6use jrsonnet_parser::{BinaryOpType, ExprLocation, UnaryOpType};
6use jrsonnet_types::ValType;7use jrsonnet_types::ValType;
7use std::{path::PathBuf, rc::Rc};8use std::{path::PathBuf, rc::Rc};
10#[derive(Error, Debug, Clone)]11#[derive(Error, Debug, Clone)]
11pub enum Error {12pub enum Error {
12	#[error("intrinsic not found: {0}")]13	#[error("intrinsic not found: {0}")]
13	IntrinsicNotFound(Rc<str>),14	IntrinsicNotFound(IStr),
14	#[error("argument reordering in intrisics not supported yet")]15	#[error("argument reordering in intrisics not supported yet")]
15	IntrinsicArgumentReorderingIsNotSupportedYet,16	IntrinsicArgumentReorderingIsNotSupportedYet,
1617
33	ArrayBoundsError(usize, usize),34	ArrayBoundsError(usize, usize),
3435
35	#[error("assert failed: {0}")]36	#[error("assert failed: {0}")]
36	AssertionFailed(Rc<str>),37	AssertionFailed(IStr),
3738
38	#[error("variable is not defined: {0}")]39	#[error("variable is not defined: {0}")]
39	VariableIsNotDefined(Rc<str>),40	VariableIsNotDefined(IStr),
40	#[error("type mismatch: expected {}, got {2} {0}", .1.iter().map(|e| format!("{}", e)).collect::<Vec<_>>().join(", "))]41	#[error("type mismatch: expected {}, got {2} {0}", .1.iter().map(|e| format!("{}", e)).collect::<Vec<_>>().join(", "))]
41	TypeMismatch(&'static str, Vec<ValType>, ValType),42	TypeMismatch(&'static str, Vec<ValType>, ValType),
42	#[error("no such field: {0}")]43	#[error("no such field: {0}")]
43	NoSuchField(Rc<str>),44	NoSuchField(IStr),
4445
45	#[error("only functions can be called, got {0}")]46	#[error("only functions can be called, got {0}")]
46	OnlyFunctionsCanBeCalledGot(ValType),47	OnlyFunctionsCanBeCalledGot(ValType),
47	#[error("parameter {0} is not defined")]48	#[error("parameter {0} is not defined")]
48	UnknownFunctionParameter(String),49	UnknownFunctionParameter(String),
49	#[error("argument {0} is already bound")]50	#[error("argument {0} is already bound")]
50	BindingParameterASecondTime(Rc<str>),51	BindingParameterASecondTime(IStr),
51	#[error("too many args, function has {0}")]52	#[error("too many args, function has {0}")]
52	TooManyArgsFunctionHas(usize),53	TooManyArgsFunctionHas(usize),
53	#[error("founction argument is not passed: {0}")]54	#[error("founction argument is not passed: {0}")]
54	FunctionParameterNotBoundInCall(Rc<str>),55	FunctionParameterNotBoundInCall(IStr),
5556
56	#[error("external variable is not defined: {0}")]57	#[error("external variable is not defined: {0}")]
57	UndefinedExternalVariable(Rc<str>),58	UndefinedExternalVariable(IStr),
58	#[error("native is not defined: {0}")]59	#[error("native is not defined: {0}")]
59	UndefinedExternalFunction(Rc<str>),60	UndefinedExternalFunction(IStr),
6061
61	#[error("field name should be string, got {0}")]62	#[error("field name should be string, got {0}")]
62	FieldMustBeStringGot(ValType),63	FieldMustBeStringGot(ValType),
6364
64	#[error("attempted to index array with string {0}")]65	#[error("attempted to index array with string {0}")]
65	AttemptedIndexAnArrayWithString(Rc<str>),66	AttemptedIndexAnArrayWithString(IStr),
66	#[error("{0} index type should be {1}, got {2}")]67	#[error("{0} index type should be {1}, got {2}")]
67	ValueIndexMustBeTypeGot(ValType, ValType, ValType),68	ValueIndexMustBeTypeGot(ValType, ValType, ValType),
68	#[error("cant index into {0}")]69	#[error("cant index into {0}")]
86	)]87	)]
87	ImportSyntaxError {88	ImportSyntaxError {
88		path: Rc<PathBuf>,89		path: Rc<PathBuf>,
89		source_code: Rc<str>,90		source_code: IStr,
90		error: Box<jrsonnet_parser::ParseError>,91		error: Box<jrsonnet_parser::ParseError>,
91	},92	},
9293
93	#[error("runtime error: {0}")]94	#[error("runtime error: {0}")]
94	RuntimeError(Rc<str>),95	RuntimeError(IStr),
95	#[error("stack overflow, try to reduce recursion, or set --max-stack to bigger value")]96	#[error("stack overflow, try to reduce recursion, or set --max-stack to bigger value")]
96	StackOverflow,97	StackOverflow,
97	#[error("tried to index by fractional value")]98	#[error("tried to index by fractional value")]

3	ContextCreator, FuncDesc, FuncVal, LazyBinding, LazyVal, ObjMember, ObjValue, Result, Val,3	ContextCreator, FuncDesc, FuncVal, LazyBinding, LazyVal, ObjMember, ObjValue, Result, Val,
4};4};
5use closure::closure;5use closure::closure;
6use jrsonnet_interner::IStr;
6use jrsonnet_parser::{7use jrsonnet_parser::{
7	ArgsDesc, AssertStmt, BinaryOpType, BindSpec, CompSpec, Expr, ExprLocation, FieldMember,8	ArgsDesc, AssertStmt, BinaryOpType, BindSpec, CompSpec, Expr, ExprLocation, FieldMember,
8	ForSpecData, IfSpecData, LiteralType, LocExpr, Member, ObjBody, ParamsDesc, UnaryOpType,9	ForSpecData, IfSpecData, LiteralType, LocExpr, Member, ObjBody, ParamsDesc, UnaryOpType,
12use rustc_hash::FxHashMap;13use rustc_hash::FxHashMap;
13use std::{collections::HashMap, rc::Rc};14use std::{collections::HashMap, rc::Rc};
1415
15pub fn evaluate_binding(b: &BindSpec, context_creator: ContextCreator) -> (Rc<str>, LazyBinding) {16pub fn evaluate_binding(b: &BindSpec, context_creator: ContextCreator) -> (IStr, LazyBinding) {
16	let b = b.clone();17	let b = b.clone();
17	if let Some(params) = &b.params {18	if let Some(params) = &b.params {
18		let params = params.clone();19		let params = params.clone();
45	}46	}
46}47}
4748
48pub fn evaluate_method(ctx: Context, name: Rc<str>, params: ParamsDesc, body: LocExpr) -> Val {49pub fn evaluate_method(ctx: Context, name: IStr, params: ParamsDesc, body: LocExpr) -> Val {
49	Val::Func(Rc::new(FuncVal::Normal(FuncDesc {50	Val::Func(Rc::new(FuncVal::Normal(FuncDesc {
50		name,51		name,
51		ctx,52		ctx,
57pub fn evaluate_field_name(58pub fn evaluate_field_name(
58	context: Context,59	context: Context,
59	field_name: &jrsonnet_parser::FieldName,60	field_name: &jrsonnet_parser::FieldName,
60) -> Result<Option<Rc<str>>> {61) -> Result<Option<IStr>> {
61	Ok(match field_name {62	Ok(match field_name {
62		jrsonnet_parser::FieldName::Fixed(n) => Some(n.clone()),63		jrsonnet_parser::FieldName::Fixed(n) => Some(n.clone()),
63		jrsonnet_parser::FieldName::Dyn(expr) => {64		jrsonnet_parser::FieldName::Dyn(expr) => {
182	})183	})
183}184}
184185
185future_wrapper!(HashMap<Rc<str>, LazyBinding>, FutureNewBindings);186future_wrapper!(HashMap<IStr, LazyBinding>, FutureNewBindings);
186future_wrapper!(ObjValue, FutureObjValue);187future_wrapper!(ObjValue, FutureObjValue);
187188
188pub fn evaluate_comp<T>(189pub fn evaluate_comp<T>(
230		})231		})
231	);232	);
232	{233	{
233		let mut bindings: HashMap<Rc<str>, LazyBinding> = HashMap::new();234		let mut bindings: HashMap<IStr, LazyBinding> = HashMap::new();
234		for (n, b) in members235		for (n, b) in members
235			.iter()236			.iter()
236			.filter_map(|m| match m {237			.filter_map(|m| match m {
334							)?)335							)?)
335						})336						})
336					);337					);
337					let mut bindings: HashMap<Rc<str>, LazyBinding> = HashMap::new();338					let mut bindings: HashMap<IStr, LazyBinding> = HashMap::new();
338					for (n, b) in obj339					for (n, b) in obj
339						.pre_locals340						.pre_locals
340						.iter()341						.iter()
401	})402	})
402}403}
403404
404pub fn evaluate_named(context: Context, lexpr: &LocExpr, name: Rc<str>) -> Result<Val> {405pub fn evaluate_named(context: Context, lexpr: &LocExpr, name: IStr) -> Result<Val> {
405	use Expr::*;406	use Expr::*;
406	let LocExpr(expr, _loc) = lexpr;407	let LocExpr(expr, _loc) = lexpr;
407	Ok(match &**expr {408	Ok(match &**expr {
498			}499			}
499		}500		}
500		LocalExpr(bindings, returned) => {501		LocalExpr(bindings, returned) => {
501			let mut new_bindings: HashMap<Rc<str>, LazyBinding> = HashMap::new();502			let mut new_bindings: HashMap<IStr, LazyBinding> = HashMap::new();
502			let future_context = Context::new_future();503			let future_context = Context::new_future();
503504
504			let context_creator = context_creator!(505			let context_creator = context_creator!(

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_interner::IStr;
3use jrsonnet_parser::{ArgsDesc, ParamsDesc};4use jrsonnet_parser::{ArgsDesc, ParamsDesc};
4use rustc_hash::FxHashMap;5use rustc_hash::FxHashMap;
5use std::{collections::HashMap, hash::BuildHasherDefault, rc::Rc};6use std::{collections::HashMap, hash::BuildHasherDefault};
67
7const NO_DEFAULT_CONTEXT: &str =8const NO_DEFAULT_CONTEXT: &str =
8	"no default context set for call with defined default parameter value";9	"no default context set for call with defined default parameter value";
66	ctx: Context,67	ctx: Context,
67	body_ctx: Option<Context>,68	body_ctx: Option<Context>,
68	params: &ParamsDesc,69	params: &ParamsDesc,
69	args: &HashMap<Rc<str>, Val>,70	args: &HashMap<IStr, Val>,
70	tailstrict: bool,71	tailstrict: bool,
71) -> Result<Context> {72) -> Result<Context> {
72	let mut out = FxHashMap::with_capacity_and_hasher(params.len(), BuildHasherDefault::default());73	let mut out = FxHashMap::with_capacity_and_hasher(params.len(), BuildHasherDefault::default());

3	throw,3	throw,
4};4};
5use fs::File;5use fs::File;
6use jrsonnet_interner::IStr;
6use std::fs;7use std::fs;
7use std::io::Read;8use std::io::Read;
8use std::{any::Any, cell::RefCell, collections::HashMap, path::PathBuf, rc::Rc};9use std::{any::Any, cell::RefCell, collections::HashMap, path::PathBuf, rc::Rc};
15	fn resolve_file(&self, from: &PathBuf, path: &PathBuf) -> Result<Rc<PathBuf>>;16	fn resolve_file(&self, from: &PathBuf, path: &PathBuf) -> Result<Rc<PathBuf>>;
1617
17	/// Reads file from filesystem, should be used only with path received from `resolve_file`18	/// Reads file from filesystem, should be used only with path received from `resolve_file`
18	fn load_file_contents(&self, resolved: &PathBuf) -> Result<Rc<str>>;19	fn load_file_contents(&self, resolved: &PathBuf) -> Result<IStr>;
1920
20	/// # Safety21	/// # Safety
21	///22	///
32		throw!(ImportNotSupported(from.clone(), path.clone()))33		throw!(ImportNotSupported(from.clone(), path.clone()))
33	}34	}
3435
35	fn load_file_contents(&self, _resolved: &PathBuf) -> Result<Rc<str>> {36	fn load_file_contents(&self, _resolved: &PathBuf) -> Result<IStr> {
36		// Can be only caused by library direct consumer, not by supplied jsonnet37		// Can be only caused by library direct consumer, not by supplied jsonnet
37		panic!("dummy resolver can't load any file")38		panic!("dummy resolver can't load any file")
38	}39	}
72			throw!(ImportFileNotFound(from.clone(), path.clone()))73			throw!(ImportFileNotFound(from.clone(), path.clone()))
73		}74		}
74	}75	}
75	fn load_file_contents(&self, id: &PathBuf) -> Result<Rc<str>> {76	fn load_file_contents(&self, id: &PathBuf) -> Result<IStr> {
76		let mut file = File::open(id).map_err(|_e| ResolvedFileNotFound(id.clone()))?;77		let mut file = File::open(id).map_err(|_e| ResolvedFileNotFound(id.clone()))?;
77		let mut out = String::new();78		let mut out = String::new();
78		file.read_to_string(&mut out)79		file.read_to_string(&mut out)
89/// Caches results of the underlying resolver90/// Caches results of the underlying resolver
90pub struct CachingImportResolver {91pub struct CachingImportResolver {
91	resolution_cache: RefCell<HashMap<ResolutionData, Result<Rc<PathBuf>>>>,92	resolution_cache: RefCell<HashMap<ResolutionData, Result<Rc<PathBuf>>>>,
92	loading_cache: RefCell<HashMap<PathBuf, Result<Rc<str>>>>,93	loading_cache: RefCell<HashMap<PathBuf, Result<IStr>>>,
93	inner: Box<dyn ImportResolver>,94	inner: Box<dyn ImportResolver>,
94}95}
95impl ImportResolver for CachingImportResolver {96impl ImportResolver for CachingImportResolver {
101			.clone()102			.clone()
102	}103	}
103104
104	fn load_file_contents(&self, resolved: &PathBuf) -> Result<Rc<str>> {105	fn load_file_contents(&self, resolved: &PathBuf) -> Result<IStr> {
105		self.loading_cache106		self.loading_cache
106			.borrow_mut()107			.borrow_mut()
107			.entry(resolved.clone())108			.entry(resolved.clone())

23pub use evaluate::*;23pub use evaluate::*;
24pub use function::parse_function_call;24pub use function::parse_function_call;
25pub use import::*;25pub use import::*;
26use jrsonnet_interner::IStr;
26use jrsonnet_parser::*;27use jrsonnet_parser::*;
27use native::NativeCallback;28use native::NativeCallback;
28pub use obj::*;29pub use obj::*;
63	/// Limits amount of stack trace items preserved64	/// Limits amount of stack trace items preserved
64	pub max_trace: usize,65	pub max_trace: usize,
65	/// Used for s`td.extVar`66	/// Used for s`td.extVar`
66	pub ext_vars: HashMap<Rc<str>, Val>,67	pub ext_vars: HashMap<IStr, Val>,
67	/// Used for ext.native68	/// Used for ext.native
68	pub ext_natives: HashMap<Rc<str>, Rc<NativeCallback>>,69	pub ext_natives: HashMap<IStr, Rc<NativeCallback>>,
69	/// TLA vars70	/// TLA vars
70	pub tla_vars: HashMap<Rc<str>, Val>,71	pub tla_vars: HashMap<IStr, Val>,
71	/// Global variables are inserted in default context72	/// Global variables are inserted in default context
72	pub globals: HashMap<Rc<str>, Val>,73	pub globals: HashMap<IStr, Val>,
73	/// Used to resolve file locations/contents74	/// Used to resolve file locations/contents
74	pub import_resolver: Box<dyn ImportResolver>,75	pub import_resolver: Box<dyn ImportResolver>,
75	/// Used in manifestification functions76	/// Used in manifestification functions
102	stack_depth: usize,103	stack_depth: usize,
103	/// Contains file source codes and evaluation results for imports and pretty-printed stacktraces104	/// Contains file source codes and evaluation results for imports and pretty-printed stacktraces
104	files: HashMap<Rc<PathBuf>, FileData>,105	files: HashMap<Rc<PathBuf>, FileData>,
105	str_files: HashMap<Rc<PathBuf>, Rc<str>>,106	str_files: HashMap<Rc<PathBuf>, IStr>,
106}107}
107108
108pub struct FileData {109pub struct FileData {
109	source_code: Rc<str>,110	source_code: IStr,
110	parsed: LocExpr,111	parsed: LocExpr,
111	evaluated: Option<Val>,112	evaluated: Option<Val>,
112}113}
144145
145impl EvaluationState {146impl EvaluationState {
146	/// Parses and adds file as loaded147	/// Parses and adds file as loaded
147	pub fn add_file(&self, path: Rc<PathBuf>, source_code: Rc<str>) -> Result<()> {148	pub fn add_file(&self, path: Rc<PathBuf>, source_code: IStr) -> Result<()> {
148		self.add_parsed_file(149		self.add_parsed_file(
149			path.clone(),150			path.clone(),
150			source_code.clone(),151			source_code.clone(),
169	pub fn add_parsed_file(170	pub fn add_parsed_file(
170		&self,171		&self,
171		name: Rc<PathBuf>,172		name: Rc<PathBuf>,
172		source_code: Rc<str>,173		source_code: IStr,
173		parsed: LocExpr,174		parsed: LocExpr,
174	) -> Result<()> {175	) -> Result<()> {
175		self.data_mut().files.insert(176		self.data_mut().files.insert(
183184
184		Ok(())185		Ok(())
185	}186	}
186	pub fn get_source(&self, name: &PathBuf) -> Option<Rc<str>> {187	pub fn get_source(&self, name: &PathBuf) -> Option<IStr> {
187		let ro_map = &self.data().files;188		let ro_map = &self.data().files;
188		ro_map.get(name).map(|value| value.source_code.clone())189		ro_map.get(name).map(|value| value.source_code.clone())
189	}190	}
205		self.add_file(file_path.clone(), contents)?;206		self.add_file(file_path.clone(), contents)?;
206		self.evaluate_loaded_file_raw(&file_path)207		self.evaluate_loaded_file_raw(&file_path)
207	}208	}
208	pub(crate) fn import_file_str(&self, from: &PathBuf, path: &PathBuf) -> Result<Rc<str>> {209	pub(crate) fn import_file_str(&self, from: &PathBuf, path: &PathBuf) -> Result<IStr> {
209		let path = self.resolve_file(from, path)?;210		let path = self.resolve_file(from, path)?;
210		if !self.data().str_files.contains_key(&path) {211		if !self.data().str_files.contains_key(&path) {
211			let file_str = self.load_file_contents(&path)?;212			let file_str = self.load_file_contents(&path)?;
257	/// Creates context with all passed global variables258	/// Creates context with all passed global variables
258	pub fn create_default_context(&self) -> Result<Context> {259	pub fn create_default_context(&self) -> Result<Context> {
259		let globals = &self.settings().globals;260		let globals = &self.settings().globals;
260		let mut new_bindings: HashMap<Rc<str>, LazyBinding> = HashMap::new();261		let mut new_bindings: HashMap<IStr, LazyBinding> = HashMap::new();
261		for (name, value) in globals.iter() {262		for (name, value) in globals.iter() {
262			new_bindings.insert(263			new_bindings.insert(
263				name.clone(),264				name.clone(),
321		out322		out
322	}323	}
323324
324	pub fn manifest(&self, val: Val) -> Result<Rc<str>> {325	pub fn manifest(&self, val: Val) -> Result<IStr> {
325		self.run_in_state(|| val.manifest(&self.manifest_format()))326		self.run_in_state(|| val.manifest(&self.manifest_format()))
326	}327	}
327	pub fn manifest_multi(&self, val: Val) -> Result<Vec<(Rc<str>, Rc<str>)>> {328	pub fn manifest_multi(&self, val: Val) -> Result<Vec<(IStr, IStr)>> {
328		self.run_in_state(|| val.manifest_multi(&self.manifest_format()))329		self.run_in_state(|| val.manifest_multi(&self.manifest_format()))
329	}330	}
330	pub fn manifest_stream(&self, val: Val) -> Result<Vec<Rc<str>>> {331	pub fn manifest_stream(&self, val: Val) -> Result<Vec<IStr>> {
331		self.run_in_state(|| val.manifest_stream(&self.manifest_format()))332		self.run_in_state(|| val.manifest_stream(&self.manifest_format()))
332	}333	}
333334
371		self.run_in_state(|| self.import_file(&PathBuf::from("."), name))372		self.run_in_state(|| self.import_file(&PathBuf::from("."), name))
372	}373	}
373	/// Parses and evaluates the given snippet374	/// Parses and evaluates the given snippet
374	pub fn evaluate_snippet_raw(&self, source: Rc<PathBuf>, code: Rc<str>) -> Result<Val> {375	pub fn evaluate_snippet_raw(&self, source: Rc<PathBuf>, code: IStr) -> Result<Val> {
375		let parsed = parse(376		let parsed = parse(
376			&code,377			&code,
377			&ParserSettings {378			&ParserSettings {
391392
392/// Settings utilities393/// Settings utilities
393impl EvaluationState {394impl EvaluationState {
394	pub fn add_ext_var(&self, name: Rc<str>, value: Val) {395	pub fn add_ext_var(&self, name: IStr, value: Val) {
395		self.settings_mut().ext_vars.insert(name, value);396		self.settings_mut().ext_vars.insert(name, value);
396	}397	}
397	pub fn add_ext_str(&self, name: Rc<str>, value: Rc<str>) {398	pub fn add_ext_str(&self, name: IStr, value: IStr) {
398		self.add_ext_var(name, Val::Str(value));399		self.add_ext_var(name, Val::Str(value));
399	}400	}
400	pub fn add_ext_code(&self, name: Rc<str>, code: Rc<str>) -> Result<()> {401	pub fn add_ext_code(&self, name: IStr, code: IStr) -> Result<()> {
401		let value =402		let value =
402			self.evaluate_snippet_raw(Rc::new(PathBuf::from(format!("ext_code {}", name))), code)?;403			self.evaluate_snippet_raw(Rc::new(PathBuf::from(format!("ext_code {}", name))), code)?;
403		self.add_ext_var(name, value);404		self.add_ext_var(name, value);
404		Ok(())405		Ok(())
405	}406	}
406407
407	pub fn add_tla(&self, name: Rc<str>, value: Val) {408	pub fn add_tla(&self, name: IStr, value: Val) {
408		self.settings_mut().tla_vars.insert(name, value);409		self.settings_mut().tla_vars.insert(name, value);
409	}410	}
410	pub fn add_tla_str(&self, name: Rc<str>, value: Rc<str>) {411	pub fn add_tla_str(&self, name: IStr, value: IStr) {
411		self.add_tla(name, Val::Str(value));412		self.add_tla(name, Val::Str(value));
412	}413	}
413	pub fn add_tla_code(&self, name: Rc<str>, code: Rc<str>) -> Result<()> {414	pub fn add_tla_code(&self, name: IStr, code: IStr) -> Result<()> {
414		let value =415		let value =
415			self.evaluate_snippet_raw(Rc::new(PathBuf::from(format!("tla_code {}", name))), code)?;416			self.evaluate_snippet_raw(Rc::new(PathBuf::from(format!("tla_code {}", name))), code)?;
416		self.add_tla(name, value);417		self.add_tla(name, value);
420	pub fn resolve_file(&self, from: &PathBuf, path: &PathBuf) -> Result<Rc<PathBuf>> {421	pub fn resolve_file(&self, from: &PathBuf, path: &PathBuf) -> Result<Rc<PathBuf>> {
421		Ok(self.settings().import_resolver.resolve_file(from, path)?)422		Ok(self.settings().import_resolver.resolve_file(from, path)?)
422	}423	}
423	pub fn load_file_contents(&self, path: &PathBuf) -> Result<Rc<str>> {424	pub fn load_file_contents(&self, path: &PathBuf) -> Result<IStr> {
424		Ok(self.settings().import_resolver.load_file_contents(path)?)425		Ok(self.settings().import_resolver.load_file_contents(path)?)
425	}426	}
426427
431		self.settings_mut().import_resolver = resolver;432		self.settings_mut().import_resolver = resolver;
432	}433	}
433434
434	pub fn add_native(&self, name: Rc<str>, cb: Rc<NativeCallback>) {435	pub fn add_native(&self, name: IStr, cb: Rc<NativeCallback>) {
435		self.settings_mut().ext_natives.insert(name, cb);436		self.settings_mut().ext_natives.insert(name, cb);
436	}437	}
437438
468pub mod tests {469pub mod tests {
469	use super::Val;470	use super::Val;
470	use crate::{error::Error::*, primitive_equals, EvaluationState};471	use crate::{error::Error::*, primitive_equals, EvaluationState};
472	use jrsonnet_interner::IStr;
471	use jrsonnet_parser::*;473	use jrsonnet_parser::*;
472	use std::{path::PathBuf, rc::Rc};474	use std::{path::PathBuf, rc::Rc};
473475
905		Ok(())907		Ok(())
906	}908	}
907909
908	struct TestImportResolver(Rc<str>);910	struct TestImportResolver(IStr);
909	impl crate::import::ImportResolver for TestImportResolver {911	impl crate::import::ImportResolver for TestImportResolver {
910		fn resolve_file(&self, _: &PathBuf, _: &PathBuf) -> crate::error::Result<Rc<PathBuf>> {912		fn resolve_file(&self, _: &PathBuf, _: &PathBuf) -> crate::error::Result<Rc<PathBuf>> {
911			Ok(Rc::new(PathBuf::from("/test")))913			Ok(Rc::new(PathBuf::from("/test")))
912		}914		}
913915
914		fn load_file_contents(&self, _: &PathBuf) -> crate::error::Result<Rc<str>> {916		fn load_file_contents(&self, _: &PathBuf) -> crate::error::Result<IStr> {
915			Ok(self.0.clone())917			Ok(self.0.clone())
916		}918		}
917919