difftreelog
doc: move lints to Crates.io
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 // too many false-positives with .expect() calls43 clippy::missing_panics_doc,44 // false positive for IStr type. There is an configuration option for45 // such cases, but it doesn't work:46 // https://github.com/rust-lang/rust-clippy/issues/980147 clippy::mutable_key_type,48 // false positives49 clippy::redundant_pub_crate,50 // Sometimes code is fancier without that51 clippy::manual_let_else,52)]5354// For jrsonnet-macros55extern crate self as jrsonnet_evaluator;5657mod arr;58#[cfg(feature = "async-import")]59pub mod async_import;60mod ctx;61mod dynamic;62pub mod error;63mod evaluate;64pub mod function;65pub mod gc;66mod import;67mod integrations;68pub mod manifest;69mod map;70mod obj;71pub mod stack;72pub mod stdlib;73mod tla;74pub mod trace;75pub mod typed;76pub mod val;7778use std::{79 any::Any,80 cell::{Ref, RefCell, RefMut},81 fmt::{self, Debug},82 path::Path,83};8485pub use ctx::*;86pub use dynamic::*;87pub use error::{Error, ErrorKind::*, Result, ResultExt};88pub use evaluate::*;89use function::CallLocation;90use gc::{GcHashMap, TraceBox};91use hashbrown::hash_map::RawEntryMut;92pub use import::*;93use jrsonnet_gcmodule::{Cc, Trace};94pub use jrsonnet_interner::{IBytes, IStr};95#[doc(hidden)]96pub use jrsonnet_macros;97pub use jrsonnet_parser as parser;98use jrsonnet_parser::*;99pub use obj::*;100use stack::check_depth;101pub use tla::apply_tla;102pub use val::{Thunk, Val};103104/// Thunk without bound `super`/`this`105/// object inheritance may be overriden multiple times, and will be fixed only on field read106pub trait Unbound: Trace {107 /// Type of value after object context is bound108 type Bound;109 /// Create value bound to specified object context110 fn bind(&self, sup: Option<ObjValue>, this: Option<ObjValue>) -> Result<Self::Bound>;111}112113/// Object fields may, or may not depend on `this`/`super`, this enum allows cheaper reuse of object-independent fields for native code114/// Standard jsonnet fields are always unbound115#[derive(Clone, Trace)]116pub enum MaybeUnbound {117 /// Value needs to be bound to `this`/`super`118 Unbound(Cc<TraceBox<dyn Unbound<Bound = Val>>>),119 /// Value is object-independent120 Bound(Thunk<Val>),121}122123impl Debug for MaybeUnbound {124 fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {125 write!(f, "MaybeUnbound")126 }127}128impl MaybeUnbound {129 /// Attach object context to value, if required130 pub fn evaluate(&self, sup: Option<ObjValue>, this: Option<ObjValue>) -> Result<Val> {131 match self {132 Self::Unbound(v) => v.bind(sup, this),133 Self::Bound(v) => Ok(v.evaluate()?),134 }135 }136}137138/// During import, this trait will be called to create initial context for file.139/// It may initialize global variables, stdlib for example.140pub trait ContextInitializer: Trace {141 /// For which size the builder should be preallocated142 fn reserve_vars(&self) -> usize {143 0144 }145 /// Initialize default file context.146 /// Has default implementation, which calls `populate`.147 /// Prefer to always implement `populate` instead.148 fn initialize(&self, state: State, for_file: Source) -> Context {149 let mut builder = ContextBuilder::with_capacity(state, self.reserve_vars());150 self.populate(for_file, &mut builder);151 builder.build()152 }153 /// For composability: extend builder. May panic if this initialization is not supported,154 /// and the context may only be created via `initialize`.155 fn populate(&self, for_file: Source, builder: &mut ContextBuilder);156 /// Allows upcasting from abstract to concrete context initializer.157 /// jrsonnet by itself doesn't use this method, it is allowed for it to panic.158 fn as_any(&self) -> &dyn Any;159}160161/// Context initializer which adds nothing.162impl ContextInitializer for () {163 fn populate(&self, _for_file: Source, _builder: &mut ContextBuilder) {}164 fn as_any(&self) -> &dyn Any {165 self166 }167}168169macro_rules! impl_context_initializer {170 ($($gen:ident)*) => {171 #[allow(non_snake_case)]172 impl<$($gen: ContextInitializer + Trace,)*> ContextInitializer for ($($gen,)*) {173 fn reserve_vars(&self) -> usize {174 let mut out = 0;175 let ($($gen,)*) = self;176 $(out += $gen.reserve_vars();)*177 out178 }179 fn populate(&self, for_file: Source, builder: &mut ContextBuilder) {180 let ($($gen,)*) = self;181 $($gen.populate(for_file.clone(), builder);)*182 }183 fn as_any(&self) -> &dyn Any {184 self185 }186 }187 };188 ($($cur:ident)* @ $c:ident $($rest:ident)*) => {189 impl_context_initializer!($($cur)*);190 impl_context_initializer!($($cur)* $c @ $($rest)*);191 };192 ($($cur:ident)* @) => {193 impl_context_initializer!($($cur)*);194 }195}196impl_context_initializer! {197 A @ B C D E F G198}199200/// Dynamically reconfigurable evaluation settings201#[derive(Trace)]202pub struct EvaluationSettings {203 /// Context initializer, which will be used for imports and everything204 /// [`NoopContextInitializer`] is used by default, most likely you want to have `jrsonnet-stdlib`205 pub context_initializer: TraceBox<dyn ContextInitializer>,206 /// Used to resolve file locations/contents207 pub import_resolver: TraceBox<dyn ImportResolver>,208}209impl Default for EvaluationSettings {210 fn default() -> Self {211 Self {212 context_initializer: tb!(()),213 import_resolver: tb!(DummyImportResolver),214 }215 }216}217218#[derive(Trace)]219struct FileData {220 string: Option<IStr>,221 bytes: Option<IBytes>,222 parsed: Option<LocExpr>,223 evaluated: Option<Val>,224225 evaluating: bool,226}227impl FileData {228 fn new_string(data: IStr) -> Self {229 Self {230 string: Some(data),231 bytes: None,232 parsed: None,233 evaluated: None,234 evaluating: false,235 }236 }237 fn new_bytes(data: IBytes) -> Self {238 Self {239 string: None,240 bytes: Some(data),241 parsed: None,242 evaluated: None,243 evaluating: false,244 }245 }246 pub(crate) fn get_string(&mut self) -> Option<IStr> {247 if self.string.is_none() {248 self.string = Some(249 self.bytes250 .as_ref()251 .expect("either string or bytes should be set")252 .clone()253 .cast_str()?,254 );255 }256 Some(self.string.clone().expect("just set"))257 }258}259260#[derive(Default, Trace)]261pub struct EvaluationStateInternals {262 /// Internal state263 file_cache: RefCell<GcHashMap<SourcePath, FileData>>,264 /// Settings, safe to change at runtime265 settings: RefCell<EvaluationSettings>,266}267268/// Maintains stack trace and import resolution269#[derive(Default, Clone, Trace)]270pub struct State(Cc<EvaluationStateInternals>);271272impl State {273 /// Should only be called with path retrieved from [`resolve_path`], may panic otherwise274 pub fn import_resolved_str(&self, path: SourcePath) -> Result<IStr> {275 let mut file_cache = self.file_cache();276 let mut file = file_cache.raw_entry_mut().from_key(&path);277278 let file = match file {279 RawEntryMut::Occupied(ref mut d) => d.get_mut(),280 RawEntryMut::Vacant(v) => {281 let data = self.settings().import_resolver.load_file_contents(&path)?;282 v.insert(283 path.clone(),284 FileData::new_string(285 std::str::from_utf8(&data)286 .map_err(|_| ImportBadFileUtf8(path.clone()))?287 .into(),288 ),289 )290 .1291 }292 };293 Ok(file294 .get_string()295 .ok_or_else(|| ImportBadFileUtf8(path.clone()))?)296 }297 /// Should only be called with path retrieved from [`resolve_path`], may panic otherwise298 pub fn import_resolved_bin(&self, path: SourcePath) -> Result<IBytes> {299 let mut file_cache = self.file_cache();300 let mut file = file_cache.raw_entry_mut().from_key(&path);301302 let file = match file {303 RawEntryMut::Occupied(ref mut d) => d.get_mut(),304 RawEntryMut::Vacant(v) => {305 let data = self.settings().import_resolver.load_file_contents(&path)?;306 v.insert(path.clone(), FileData::new_bytes(data.as_slice().into()))307 .1308 }309 };310 if let Some(str) = &file.bytes {311 return Ok(str.clone());312 }313 if file.bytes.is_none() {314 file.bytes = Some(315 file.string316 .as_ref()317 .expect("either string or bytes should be set")318 .clone()319 .cast_bytes(),320 );321 }322 Ok(file.bytes.as_ref().expect("just set").clone())323 }324 /// Should only be called with path retrieved from [`resolve_path`], may panic otherwise325 pub fn import_resolved(&self, path: SourcePath) -> Result<Val> {326 let mut file_cache = self.file_cache();327 let mut file = file_cache.raw_entry_mut().from_key(&path);328329 let file = match file {330 RawEntryMut::Occupied(ref mut d) => d.get_mut(),331 RawEntryMut::Vacant(v) => {332 let data = self.settings().import_resolver.load_file_contents(&path)?;333 v.insert(334 path.clone(),335 FileData::new_string(336 std::str::from_utf8(&data)337 .map_err(|_| ImportBadFileUtf8(path.clone()))?338 .into(),339 ),340 )341 .1342 }343 };344 if let Some(val) = &file.evaluated {345 return Ok(val.clone());346 }347 let code = file348 .get_string()349 .ok_or_else(|| ImportBadFileUtf8(path.clone()))?;350 let file_name = Source::new(path.clone(), code.clone());351 if file.parsed.is_none() {352 file.parsed = Some(353 jrsonnet_parser::parse(354 &code,355 &ParserSettings {356 source: file_name.clone(),357 },358 )359 .map_err(|e| ImportSyntaxError {360 path: file_name.clone(),361 error: Box::new(e),362 })?,363 );364 }365 let parsed = file.parsed.as_ref().expect("just set").clone();366 if file.evaluating {367 bail!(InfiniteRecursionDetected)368 }369 file.evaluating = true;370 // Dropping file cache guard here, as evaluation may use this map too371 drop(file_cache);372 let res = evaluate(self.create_default_context(file_name), &parsed);373374 let mut file_cache = self.file_cache();375 let mut file = file_cache.raw_entry_mut().from_key(&path);376377 let RawEntryMut::Occupied(file) = &mut file else {378 unreachable!("this file was just here!")379 };380 let file = file.get_mut();381 file.evaluating = false;382 match res {383 Ok(v) => {384 file.evaluated = Some(v.clone());385 Ok(v)386 }387 Err(e) => Err(e),388 }389 }390391 /// Has same semantics as `import 'path'` called from `from` file392 pub fn import_from(&self, from: &SourcePath, path: &str) -> Result<Val> {393 let resolved = self.resolve_from(from, path)?;394 self.import_resolved(resolved)395 }396 pub fn import(&self, path: impl AsRef<Path>) -> Result<Val> {397 let resolved = self.resolve(path)?;398 self.import_resolved(resolved)399 }400401 /// Creates context with all passed global variables402 pub fn create_default_context(&self, source: Source) -> Context {403 let context_initializer = &self.settings().context_initializer;404 context_initializer.initialize(self.clone(), source)405 }406407 /// Creates context with all passed global variables, calling custom modifier408 pub fn create_default_context_with(409 &self,410 source: Source,411 context_initializer: impl ContextInitializer,412 ) -> Context {413 let default_initializer = &self.settings().context_initializer;414 let mut builder = ContextBuilder::with_capacity(415 self.clone(),416 default_initializer.reserve_vars() + context_initializer.reserve_vars(),417 );418 default_initializer.populate(source.clone(), &mut builder);419 context_initializer.populate(source, &mut builder);420421 builder.build()422 }423424 /// Executes code creating a new stack frame425 pub fn push<T>(426 e: CallLocation<'_>,427 frame_desc: impl FnOnce() -> String,428 f: impl FnOnce() -> Result<T>,429 ) -> Result<T> {430 let _guard = check_depth()?;431432 f().with_description_src(e, frame_desc)433 }434435 /// Executes code creating a new stack frame436 pub fn push_val(437 &self,438 e: &ExprLocation,439 frame_desc: impl FnOnce() -> String,440 f: impl FnOnce() -> Result<Val>,441 ) -> Result<Val> {442 let _guard = check_depth()?;443444 f().with_description_src(e, frame_desc)445 }446 /// Executes code creating a new stack frame447 pub fn push_description<T>(448 frame_desc: impl FnOnce() -> String,449 f: impl FnOnce() -> Result<T>,450 ) -> Result<T> {451 let _guard = check_depth()?;452453 f().with_description(frame_desc)454 }455}456457/// Internals458impl State {459 fn file_cache(&self) -> RefMut<'_, GcHashMap<SourcePath, FileData>> {460 self.0.file_cache.borrow_mut()461 }462 pub fn settings(&self) -> Ref<'_, EvaluationSettings> {463 self.0.settings.borrow()464 }465 pub fn settings_mut(&self) -> RefMut<'_, EvaluationSettings> {466 self.0.settings.borrow_mut()467 }468 pub fn add_global(&self, name: IStr, value: Thunk<Val>) {469 #[derive(Trace)]470 struct GlobalsCtx {471 globals: RefCell<GcHashMap<IStr, Thunk<Val>>>,472 inner: TraceBox<dyn ContextInitializer>,473 }474 impl ContextInitializer for GlobalsCtx {475 fn reserve_vars(&self) -> usize {476 self.inner.reserve_vars() + self.globals.borrow().len()477 }478 fn populate(&self, for_file: Source, builder: &mut ContextBuilder) {479 self.inner.populate(for_file, builder);480 for (name, val) in self.globals.borrow().iter() {481 builder.bind(name.clone(), val.clone());482 }483 }484485 fn as_any(&self) -> &dyn Any {486 self487 }488 }489 let mut settings = self.settings_mut();490 let initializer = &mut settings.context_initializer;491 if let Some(global) = initializer.as_any().downcast_ref::<GlobalsCtx>() {492 global.globals.borrow_mut().insert(name, value);493 } else {494 let inner = std::mem::replace(&mut settings.context_initializer, tb!(()));495 settings.context_initializer = tb!(GlobalsCtx {496 globals: {497 let mut out = GcHashMap::with_capacity(1);498 out.insert(name, value);499 RefCell::new(out)500 },501 inner502 });503 }504 }505}506507#[derive(Trace)]508pub struct InitialUnderscore(pub Thunk<Val>);509impl ContextInitializer for InitialUnderscore {510 fn populate(&self, _for_file: Source, builder: &mut ContextBuilder) {511 builder.bind("_", self.0.clone());512 }513514 fn as_any(&self) -> &dyn Any {515 self516 }517}518519/// Raw methods evaluate passed values but don't perform TLA execution520impl State {521 /// Parses and evaluates the given snippet522 pub fn evaluate_snippet(&self, name: impl Into<IStr>, code: impl Into<IStr>) -> Result<Val> {523 let code = code.into();524 let source = Source::new_virtual(name.into(), code.clone());525 let parsed = jrsonnet_parser::parse(526 &code,527 &ParserSettings {528 source: source.clone(),529 },530 )531 .map_err(|e| ImportSyntaxError {532 path: source.clone(),533 error: Box::new(e),534 })?;535 evaluate(self.create_default_context(source), &parsed)536 }537 /// Parses and evaluates the given snippet with custom context modifier538 pub fn evaluate_snippet_with(539 &self,540 name: impl Into<IStr>,541 code: impl Into<IStr>,542 context_initializer: impl ContextInitializer,543 ) -> Result<Val> {544 let code = code.into();545 let source = Source::new_virtual(name.into(), code.clone());546 let parsed = jrsonnet_parser::parse(547 &code,548 &ParserSettings {549 source: source.clone(),550 },551 )552 .map_err(|e| ImportSyntaxError {553 path: source.clone(),554 error: Box::new(e),555 })?;556 evaluate(557 self.create_default_context_with(source, context_initializer),558 &parsed,559 )560 }561}562563/// Settings utilities564impl State {565 // Only panics in case of [`ImportResolver`] contract violation566 #[allow(clippy::missing_panics_doc)]567 pub fn resolve_from(&self, from: &SourcePath, path: &str) -> Result<SourcePath> {568 self.import_resolver().resolve_from(from, path.as_ref())569 }570571 // Only panics in case of [`ImportResolver`] contract violation572 #[allow(clippy::missing_panics_doc)]573 pub fn resolve(&self, path: impl AsRef<Path>) -> Result<SourcePath> {574 self.import_resolver().resolve(path.as_ref())575 }576 pub fn import_resolver(&self) -> Ref<'_, dyn ImportResolver> {577 Ref::map(self.settings(), |s| &*s.import_resolver)578 }579 pub fn set_import_resolver(&self, resolver: impl ImportResolver) {580 self.settings_mut().import_resolver = tb!(resolver);581 }582 pub fn context_initializer(&self) -> Ref<'_, dyn ContextInitializer> {583 Ref::map(self.settings(), |s| &*s.context_initializer)584 }585 pub fn set_context_initializer(&self, initializer: impl ContextInitializer) {586 self.settings_mut().context_initializer = tb!(initializer);587 }588}