difftreelog
feat more ContextInitializer impls for tuples
in: master
1 file changed
crates/jrsonnet-evaluator/src/lib.rsdiffbeforeafterboth1//! jsonnet interpreter implementation2#![cfg_attr(feature = "nightly", feature(thread_local, type_alias_impl_trait))]3#![deny(unsafe_op_in_unsafe_fn)]4#![warn(5 clippy::all,6 clippy::nursery,7 clippy::pedantic,8 // missing_docs,9 elided_lifetimes_in_paths,10 explicit_outlives_requirements,11 noop_method_call,12 single_use_lifetimes,13 variant_size_differences,14 rustdoc::all15)]16#![allow(17 macro_expanded_macro_exports_accessed_by_absolute_paths,18 clippy::ptr_arg,19 // Too verbose20 clippy::must_use_candidate,21 // A lot of functions pass around errors thrown by code22 clippy::missing_errors_doc,23 // A lot of pointers have interior Rc24 clippy::needless_pass_by_value,25 // Its fine26 clippy::wildcard_imports,27 clippy::enum_glob_use,28 clippy::module_name_repetitions,29 // TODO: fix individual issues, however this works as intended almost everywhere30 clippy::cast_precision_loss,31 clippy::cast_possible_wrap,32 clippy::cast_possible_truncation,33 clippy::cast_sign_loss,34 // False positives35 // https://github.com/rust-lang/rust-clippy/issues/690236 clippy::use_self,37 // https://github.com/rust-lang/rust-clippy/issues/853938 clippy::iter_with_drain,39 clippy::type_repetition_in_bounds,40 // ci is being run with nightly, but library should work on stable41 clippy::missing_const_for_fn,42)]4344// For jrsonnet-macros45extern crate self as jrsonnet_evaluator;4647mod arr;48#[cfg(feature = "async-import")]49pub mod async_import;50mod ctx;51mod dynamic;52pub mod error;53mod evaluate;54pub mod function;55pub mod gc;56mod import;57mod integrations;58pub mod manifest;59mod map;60mod obj;61pub mod stack;62pub mod stdlib;63mod tla;64pub mod trace;65pub mod typed;66pub mod val;6768use std::{69 any::Any,70 cell::{Ref, RefCell, RefMut},71 fmt::{self, Debug},72 path::Path,73};7475pub use ctx::*;76pub use dynamic::*;77pub use error::{Error, ErrorKind::*, Result, ResultExt};78pub use evaluate::*;79use function::CallLocation;80use gc::{GcHashMap, TraceBox};81use hashbrown::hash_map::RawEntryMut;82pub use import::*;83use jrsonnet_gcmodule::{Cc, Trace};84pub use jrsonnet_interner::{IBytes, IStr};85pub use jrsonnet_parser as parser;86use jrsonnet_parser::*;87pub use obj::*;88use stack::check_depth;89pub use tla::apply_tla;90pub use val::{Thunk, Val};9192/// Thunk without bound `super`/`this`93/// object inheritance may be overriden multiple times, and will be fixed only on field read94pub trait Unbound: Trace {95 /// Type of value after object context is bound96 type Bound;97 /// Create value bound to specified object context98 fn bind(&self, sup: Option<ObjValue>, this: Option<ObjValue>) -> Result<Self::Bound>;99}100101/// Object fields may, or may not depend on `this`/`super`, this enum allows cheaper reuse of object-independent fields for native code102/// Standard jsonnet fields are always unbound103#[derive(Clone, Trace)]104pub enum MaybeUnbound {105 /// Value needs to be bound to `this`/`super`106 Unbound(Cc<TraceBox<dyn Unbound<Bound = Val>>>),107 /// Value is object-independent108 Bound(Thunk<Val>),109}110111impl Debug for MaybeUnbound {112 fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {113 write!(f, "MaybeUnbound")114 }115}116impl MaybeUnbound {117 /// Attach object context to value, if required118 pub fn evaluate(&self, sup: Option<ObjValue>, this: Option<ObjValue>) -> Result<Val> {119 match self {120 Self::Unbound(v) => v.bind(sup, this),121 Self::Bound(v) => Ok(v.evaluate()?),122 }123 }124}125126/// During import, this trait will be called to create initial context for file.127/// It may initialize global variables, stdlib for example.128pub trait ContextInitializer: Trace {129 /// For which size the builder should be preallocated130 fn reserve_vars(&self) -> usize {131 0132 }133 /// Initialize default file context.134 /// Has default implementation, which calls `populate`.135 /// Prefer to always implement `populate` instead.136 fn initialize(&self, state: State, for_file: Source) -> Context {137 let mut builder = ContextBuilder::with_capacity(state, self.reserve_vars());138 self.populate(for_file, &mut builder);139 builder.build()140 }141 /// For composability: extend builder. May panic if this initialization is not supported,142 /// and the context may only be created via `initialize`.143 fn populate(&self, for_file: Source, builder: &mut ContextBuilder);144 /// Allows upcasting from abstract to concrete context initializer.145 /// jrsonnet by itself doesn't use this method, it is allowed for it to panic.146 fn as_any(&self) -> &dyn Any;147}148149/// Context initializer which adds nothing.150impl ContextInitializer for () {151 fn populate(&self, _for_file: Source, _builder: &mut ContextBuilder) {}152 fn as_any(&self) -> &dyn Any {153 self154 }155}156157macro_rules! impl_context_initializer {158 ($($gen:ident)*) => {159 #[allow(non_snake_case)]160 impl<$($gen: ContextInitializer + Trace,)*> ContextInitializer for ($($gen,)*) {161 fn reserve_vars(&self) -> usize {162 let mut out = 0;163 let ($($gen,)*) = self;164 $(out += $gen.reserve_vars();)*165 out166 }167 fn populate(&self, for_file: Source, builder: &mut ContextBuilder) {168 let ($($gen,)*) = self;169 $($gen.populate(for_file.clone(), builder);)*170 }171 fn as_any(&self) -> &dyn Any {172 self173 }174 }175 };176 ($($cur:ident)* @ $c:ident $($rest:ident)*) => {177 impl_context_initializer!($($cur)*);178 impl_context_initializer!($($cur)* $c @ $($rest)*);179 };180 ($($cur:ident)* @) => {181 impl_context_initializer!($($cur)*);182 }183}184impl_context_initializer! {185 A B @ C D E186}187188/// Dynamically reconfigurable evaluation settings189#[derive(Trace)]190pub struct EvaluationSettings {191 /// Context initializer, which will be used for imports and everything192 /// [`NoopContextInitializer`] is used by default, most likely you want to have `jrsonnet-stdlib`193 pub context_initializer: TraceBox<dyn ContextInitializer>,194 /// Used to resolve file locations/contents195 pub import_resolver: TraceBox<dyn ImportResolver>,196}197impl Default for EvaluationSettings {198 fn default() -> Self {199 Self {200 context_initializer: tb!(()),201 import_resolver: tb!(DummyImportResolver),202 }203 }204}205206#[derive(Trace)]207struct FileData {208 string: Option<IStr>,209 bytes: Option<IBytes>,210 parsed: Option<LocExpr>,211 evaluated: Option<Val>,212213 evaluating: bool,214}215impl FileData {216 fn new_string(data: IStr) -> Self {217 Self {218 string: Some(data),219 bytes: None,220 parsed: None,221 evaluated: None,222 evaluating: false,223 }224 }225 fn new_bytes(data: IBytes) -> Self {226 Self {227 string: None,228 bytes: Some(data),229 parsed: None,230 evaluated: None,231 evaluating: false,232 }233 }234 pub(crate) fn get_string(&mut self) -> Option<IStr> {235 if self.string.is_none() {236 self.string = Some(237 self.bytes238 .as_ref()239 .expect("either string or bytes should be set")240 .clone()241 .cast_str()?,242 );243 }244 Some(self.string.clone().expect("just set"))245 }246}247248#[derive(Default, Trace)]249pub struct EvaluationStateInternals {250 /// Internal state251 file_cache: RefCell<GcHashMap<SourcePath, FileData>>,252 /// Settings, safe to change at runtime253 settings: RefCell<EvaluationSettings>,254}255256/// Maintains stack trace and import resolution257#[derive(Default, Clone, Trace)]258pub struct State(Cc<EvaluationStateInternals>);259260impl State {261 /// Should only be called with path retrieved from [`resolve_path`], may panic otherwise262 pub fn import_resolved_str(&self, path: SourcePath) -> Result<IStr> {263 let mut file_cache = self.file_cache();264 let mut file = file_cache.raw_entry_mut().from_key(&path);265266 let file = match file {267 RawEntryMut::Occupied(ref mut d) => d.get_mut(),268 RawEntryMut::Vacant(v) => {269 let data = self.settings().import_resolver.load_file_contents(&path)?;270 v.insert(271 path.clone(),272 FileData::new_string(273 std::str::from_utf8(&data)274 .map_err(|_| ImportBadFileUtf8(path.clone()))?275 .into(),276 ),277 )278 .1279 }280 };281 Ok(file282 .get_string()283 .ok_or_else(|| ImportBadFileUtf8(path.clone()))?)284 }285 /// Should only be called with path retrieved from [`resolve_path`], may panic otherwise286 pub fn import_resolved_bin(&self, path: SourcePath) -> Result<IBytes> {287 let mut file_cache = self.file_cache();288 let mut file = file_cache.raw_entry_mut().from_key(&path);289290 let file = match file {291 RawEntryMut::Occupied(ref mut d) => d.get_mut(),292 RawEntryMut::Vacant(v) => {293 let data = self.settings().import_resolver.load_file_contents(&path)?;294 v.insert(path.clone(), FileData::new_bytes(data.as_slice().into()))295 .1296 }297 };298 if let Some(str) = &file.bytes {299 return Ok(str.clone());300 }301 if file.bytes.is_none() {302 file.bytes = Some(303 file.string304 .as_ref()305 .expect("either string or bytes should be set")306 .clone()307 .cast_bytes(),308 );309 }310 Ok(file.bytes.as_ref().expect("just set").clone())311 }312 /// Should only be called with path retrieved from [`resolve_path`], may panic otherwise313 pub fn import_resolved(&self, path: SourcePath) -> Result<Val> {314 let mut file_cache = self.file_cache();315 let mut file = file_cache.raw_entry_mut().from_key(&path);316317 let file = match file {318 RawEntryMut::Occupied(ref mut d) => d.get_mut(),319 RawEntryMut::Vacant(v) => {320 let data = self.settings().import_resolver.load_file_contents(&path)?;321 v.insert(322 path.clone(),323 FileData::new_string(324 std::str::from_utf8(&data)325 .map_err(|_| ImportBadFileUtf8(path.clone()))?326 .into(),327 ),328 )329 .1330 }331 };332 if let Some(val) = &file.evaluated {333 return Ok(val.clone());334 }335 let code = file336 .get_string()337 .ok_or_else(|| ImportBadFileUtf8(path.clone()))?;338 let file_name = Source::new(path.clone(), code.clone());339 if file.parsed.is_none() {340 file.parsed = Some(341 jrsonnet_parser::parse(342 &code,343 &ParserSettings {344 source: file_name.clone(),345 },346 )347 .map_err(|e| ImportSyntaxError {348 path: file_name.clone(),349 error: Box::new(e),350 })?,351 );352 }353 let parsed = file.parsed.as_ref().expect("just set").clone();354 if file.evaluating {355 throw!(InfiniteRecursionDetected)356 }357 file.evaluating = true;358 // Dropping file cache guard here, as evaluation may use this map too359 drop(file_cache);360 let res = evaluate(self.create_default_context(file_name), &parsed);361362 let mut file_cache = self.file_cache();363 let mut file = file_cache.raw_entry_mut().from_key(&path);364365 let RawEntryMut::Occupied(file) = &mut file else {366 unreachable!("this file was just here!")367 };368 let file = file.get_mut();369 file.evaluating = false;370 match res {371 Ok(v) => {372 file.evaluated = Some(v.clone());373 Ok(v)374 }375 Err(e) => Err(e),376 }377 }378379 /// Has same semantics as `import 'path'` called from `from` file380 pub fn import_from(&self, from: &SourcePath, path: &str) -> Result<Val> {381 let resolved = self.resolve_from(from, path)?;382 self.import_resolved(resolved)383 }384 pub fn import(&self, path: impl AsRef<Path>) -> Result<Val> {385 let resolved = self.resolve(path)?;386 self.import_resolved(resolved)387 }388389 /// Creates context with all passed global variables390 pub fn create_default_context(&self, source: Source) -> Context {391 let context_initializer = &self.settings().context_initializer;392 context_initializer.initialize(self.clone(), source)393 }394395 /// Creates context with all passed global variables, calling custom modifier396 pub fn create_default_context_with(397 &self,398 source: Source,399 context_initializer: impl ContextInitializer,400 ) -> Context {401 let default_initializer = &self.settings().context_initializer;402 let mut builder = ContextBuilder::with_capacity(403 self.clone(),404 default_initializer.reserve_vars() + context_initializer.reserve_vars(),405 );406 default_initializer.populate(source.clone(), &mut builder);407 context_initializer.populate(source, &mut builder);408409 builder.build()410 }411412 /// Executes code creating a new stack frame413 pub fn push<T>(414 e: CallLocation<'_>,415 frame_desc: impl FnOnce() -> String,416 f: impl FnOnce() -> Result<T>,417 ) -> Result<T> {418 let _guard = check_depth()?;419420 f().with_description_src(e, frame_desc)421 }422423 /// Executes code creating a new stack frame424 pub fn push_val(425 &self,426 e: &ExprLocation,427 frame_desc: impl FnOnce() -> String,428 f: impl FnOnce() -> Result<Val>,429 ) -> Result<Val> {430 let _guard = check_depth()?;431432 f().with_description_src(e, frame_desc)433 }434 /// Executes code creating a new stack frame435 pub fn push_description<T>(436 frame_desc: impl FnOnce() -> String,437 f: impl FnOnce() -> Result<T>,438 ) -> Result<T> {439 let _guard = check_depth()?;440441 f().with_description(frame_desc)442 }443}444445/// Internals446impl State {447 fn file_cache(&self) -> RefMut<'_, GcHashMap<SourcePath, FileData>> {448 self.0.file_cache.borrow_mut()449 }450 pub fn settings(&self) -> Ref<'_, EvaluationSettings> {451 self.0.settings.borrow()452 }453 pub fn settings_mut(&self) -> RefMut<'_, EvaluationSettings> {454 self.0.settings.borrow_mut()455 }456 pub fn add_global(&self, name: IStr, value: Thunk<Val>) {457 #[derive(Trace)]458 struct GlobalsCtx {459 globals: RefCell<GcHashMap<IStr, Thunk<Val>>>,460 inner: TraceBox<dyn ContextInitializer>,461 }462 impl ContextInitializer for GlobalsCtx {463 fn reserve_vars(&self) -> usize {464 self.inner.reserve_vars() + self.globals.borrow().len()465 }466 fn populate(&self, for_file: Source, builder: &mut ContextBuilder) {467 self.inner.populate(for_file, builder);468 for (name, val) in self.globals.borrow().iter() {469 builder.bind(name.clone(), val.clone());470 }471 }472473 fn as_any(&self) -> &dyn Any {474 self475 }476 }477 let mut settings = self.settings_mut();478 let initializer = &mut settings.context_initializer;479 if let Some(global) = initializer.as_any().downcast_ref::<GlobalsCtx>() {480 global.globals.borrow_mut().insert(name, value);481 } else {482 let inner = std::mem::replace(&mut settings.context_initializer, tb!(()));483 settings.context_initializer = tb!(GlobalsCtx {484 globals: {485 let mut out = GcHashMap::with_capacity(1);486 out.insert(name, value);487 RefCell::new(out)488 },489 inner490 });491 }492 }493}494495#[derive(Trace)]496pub struct InitialUnderscore(pub Thunk<Val>);497impl ContextInitializer for InitialUnderscore {498 fn populate(&self, _for_file: Source, builder: &mut ContextBuilder) {499 builder.bind("_".into(), self.0.clone());500 }501502 fn as_any(&self) -> &dyn Any {503 self504 }505}506507/// Raw methods evaluate passed values but don't perform TLA execution508impl State {509 /// Parses and evaluates the given snippet510 pub fn evaluate_snippet(&self, name: impl Into<IStr>, code: impl Into<IStr>) -> Result<Val> {511 let code = code.into();512 let source = Source::new_virtual(name.into(), code.clone());513 let parsed = jrsonnet_parser::parse(514 &code,515 &ParserSettings {516 source: source.clone(),517 },518 )519 .map_err(|e| ImportSyntaxError {520 path: source.clone(),521 error: Box::new(e),522 })?;523 evaluate(self.create_default_context(source), &parsed)524 }525 /// Parses and evaluates the given snippet with custom context modifier526 pub fn evaluate_snippet_with(527 &self,528 name: impl Into<IStr>,529 code: impl Into<IStr>,530 context_initializer: impl ContextInitializer,531 ) -> Result<Val> {532 let code = code.into();533 let source = Source::new_virtual(name.into(), code.clone());534 let parsed = jrsonnet_parser::parse(535 &code,536 &ParserSettings {537 source: source.clone(),538 },539 )540 .map_err(|e| ImportSyntaxError {541 path: source.clone(),542 error: Box::new(e),543 })?;544 evaluate(545 self.create_default_context_with(source, context_initializer),546 &parsed,547 )548 }549}550551/// Settings utilities552impl State {553 // Only panics in case of [`ImportResolver`] contract violation554 #[allow(clippy::missing_panics_doc)]555 pub fn resolve_from(&self, from: &SourcePath, path: &str) -> Result<SourcePath> {556 self.import_resolver().resolve_from(from, path.as_ref())557 }558559 // Only panics in case of [`ImportResolver`] contract violation560 #[allow(clippy::missing_panics_doc)]561 pub fn resolve(&self, path: impl AsRef<Path>) -> Result<SourcePath> {562 self.import_resolver().resolve(path.as_ref())563 }564 pub fn import_resolver(&self) -> Ref<'_, dyn ImportResolver> {565 Ref::map(self.settings(), |s| &*s.import_resolver)566 }567 pub fn set_import_resolver(&self, resolver: impl ImportResolver) {568 self.settings_mut().import_resolver = tb!(resolver);569 }570 pub fn context_initializer(&self) -> Ref<'_, dyn ContextInitializer> {571 Ref::map(self.settings(), |s| &*s.context_initializer)572 }573 pub fn set_context_initializer(&self, initializer: impl ContextInitializer) {574 self.settings_mut().context_initializer = tb!(initializer);575 }576}