difftreelog
refactor closure interpreter
in: master
14 files changed
crates/jrsonnet-evaluator/src/arr/mod.rsdiffbeforeafterboth--- a/crates/jrsonnet-evaluator/src/arr/mod.rs
+++ b/crates/jrsonnet-evaluator/src/arr/mod.rs
@@ -7,7 +7,12 @@
use jrsonnet_gcmodule::{Cc, cc_dyn};
-use crate::{Context, Result, Thunk, Val, analyze::LExpr, function::NativeFn, typed::IntoUntyped};
+use crate::{
+ Context, Result, Thunk, Val,
+ analyze::{ClosureShape, LExpr},
+ function::NativeFn,
+ typed::IntoUntyped,
+};
mod spec;
pub use spec::{ArrayLike, *};
@@ -36,8 +41,8 @@
Self::new(())
}
- pub fn expr(ctx: Context, exprs: Rc<Vec<LExpr>>) -> Self {
- Self::new(ExprArray::new(ctx, exprs))
+ pub fn expr(ctx: Context, shape: &ClosureShape, exprs: Rc<Vec<LExpr>>) -> Self {
+ Self::new(ExprArray::new(ctx, shape, exprs))
}
pub fn repeated(data: Self, repeats: u32) -> Option<Self> {
crates/jrsonnet-evaluator/src/arr/spec.rsdiffbeforeafterboth--- a/crates/jrsonnet-evaluator/src/arr/spec.rs
+++ b/crates/jrsonnet-evaluator/src/arr/spec.rs
@@ -12,7 +12,7 @@
use super::ArrValue;
use crate::{
Context, Error, ObjValue, Result, Thunk, Val,
- analyze::LExpr,
+ analyze::{ClosureShape, LExpr},
error::ErrorKind::InfiniteRecursionDetected,
evaluate::evaluate,
function::NativeFn,
@@ -123,9 +123,9 @@
cached: Cc<RefCell<Vec<ArrayThunk>>>,
}
impl ExprArray {
- pub fn new(ctx: Context, src: Rc<Vec<LExpr>>) -> Self {
+ pub fn new(outer: Context, shape: &ClosureShape, src: Rc<Vec<LExpr>>) -> Self {
Self {
- ctx,
+ ctx: Context::enter_using(&outer, shape),
cached: Cc::new(RefCell::new(vec![ArrayThunk::Waiting; src.len()])),
src,
}
crates/jrsonnet-evaluator/src/async_import.rsdiffbeforeafterboth--- a/crates/jrsonnet-evaluator/src/async_import.rs
+++ b/crates/jrsonnet-evaluator/src/async_import.rs
@@ -4,7 +4,7 @@
use jrsonnet_ir::{IStr, Source, SourcePath, visit::Visitor};
use rustc_hash::FxHashMap;
-use crate::{AsPathLike, FileData, ImportResolver, ResolvePathOwned, State};
+use crate::{AsPathLike, FileData, ImportResolver, ResolvePathOwned, Result, State};
pub struct Import {
path: ResolvePathOwned,
@@ -109,23 +109,23 @@
}
}
Job::ParseFile(path) => {
- if let Some(file) = s.0.file_cache.borrow_mut().get_mut(&path) {
- if file.parsed.is_none() {
- let Some(code) = file.get_string() else {
- continue;
- };
- let source = Source::new(path.clone(), code.clone());
- // If failed - then skip import
- file.parsed = crate::parse_jsonnet(&code, source).map(Rc::new).ok();
- if let Some(parsed) = &file.parsed {
- let mut imports = FoundImports(vec![]);
- imports.visit_expr(parsed);
- for import in imports.0 {
- queue.push(Job::ResolveImport {
- from: path.clone(),
- import,
- });
- }
+ if let Some(file) = s.0.file_cache.borrow_mut().get_mut(&path)
+ && file.parsed.is_none()
+ {
+ let Some(code) = file.get_string() else {
+ continue;
+ };
+ let source = Source::new(path.clone(), code.clone());
+ // If failed - then skip import
+ file.parsed = crate::parse_jsonnet(&code, source).map(Rc::new).ok();
+ if let Some(parsed) = &file.parsed {
+ let mut imports = FoundImports(vec![]);
+ imports.visit_expr(parsed);
+ for import in imports.0 {
+ queue.push(Job::ResolveImport {
+ from: path.clone(),
+ import,
+ });
}
}
}
crates/jrsonnet-evaluator/src/ctx.rsdiffbeforeafterboth1use std::{2 cell::{Cell, OnceCell, RefCell},3 clone::Clone,4 fmt::{self, Debug},5};67use educe::Educe;8use jrsonnet_gcmodule::{Cc, Trace};9use jrsonnet_interner::IStr;1011use crate::{12 Result, SupThis, Thunk, Val,13 analyze::{CaptureSlot, ClosureShape, LSlot, LocalId, LocalSlot},14 bail, error,15 error::ErrorKind::*,16};1718#[derive(Debug, Trace, Clone, Educe)]19#[educe(PartialEq)]20pub struct Context(#[educe(PartialEq(method = Cc::ptr_eq))] pub(crate) Cc<ContextInternal>);2122#[derive(Trace)]23pub(crate) struct ContextInternal {24 /// Immutable, packed at closure-create time.25 pub(crate) captures: Cc<Vec<Thunk<Val>>>,26 /// Filled during closure initialization27 pub(crate) locals: Cc<LocalsFrame>,28 pub(crate) sup_this: Option<SupThis>,29}3031impl Debug for ContextInternal {32 fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {33 f.debug_struct("ContextInternal")34 .field("captures", &self.captures.len())35 .field("locals", &self.locals)36 .field("sup_this", &self.sup_this.is_some())37 .finish()38 }39}4041#[derive(Trace, Debug)]42pub(crate) struct IterFrame {43 slots: Vec<RefCell<Option<Thunk<Val>>>>,44 captured: Cell<bool>,45}46impl IterFrame {47 pub fn new(n: u16) -> IterFrame {48 let cells: Vec<RefCell<Option<Thunk<Val>>>> = (0..n).map(|_| RefCell::new(None)).collect();49 IterFrame {50 slots: cells,51 captured: Cell::new(false),52 }53 }54 pub fn set(&self, slot: LocalSlot, value: Thunk<Val>) {55 *self.slots[slot.0 as usize].borrow_mut() = Some(value);56 }57}5859#[derive(Trace, Debug)]60pub(crate) enum LocalsFrame {61 Once1(OnceCell<Thunk<Val>>),62 /// Letrec/function/object/for frames - slots are filled during frame setup63 Once(Vec<OnceCell<Thunk<Val>>>),64 /// Comp-eager fast-path, cells are reset per iteration for the unique frames (i.e for the non-capturing thunks)65 Iter(IterFrame),66}67impl LocalsFrame {68 pub fn set(&self, slot: LocalSlot, value: Thunk<Val>) {69 match self {70 LocalsFrame::Once1(cell) => {71 debug_assert_eq!(slot.0, 0, "Once1 only holds slot 0");72 cell.set(value)73 .map_err(|_| ())74 .expect("slot already filled");75 }76 LocalsFrame::Once(cells) => {77 cells[slot.0 as usize]78 .set(value)79 .map_err(|_| ())80 .expect("slot already filled");81 }82 LocalsFrame::Iter(_) => unreachable!("iter frame has different constructors"),83 }84 }85}8687impl LocalsFrame {88 pub(crate) fn new_once(n: u16) -> Cc<Self> {89 if n == 1 {90 return Cc::new(Self::Once1(OnceCell::new()));91 }92 let cells: Vec<OnceCell<Thunk<Val>>> = (0..n).map(|_| OnceCell::new()).collect();93 Cc::new(Self::Once(cells))94 }95}9697pub(crate) struct IterContext {98 context: Context,99}100impl IterContext {101 pub(crate) fn create(&self, build: impl FnOnce(&IterFrame)) -> Result<Context> {102 if !Cc::is_unique(&self.context.0.locals) {103 bail!(EagerCompspecCaptured);104 }105 let LocalsFrame::Iter(frame) = &*self.context.0.locals else {106 unreachable!("IterContext is only created for Iter ctx");107 };108 if frame.captured.get() {109 bail!(EagerCompspecCaptured);110 }111 build(frame);112 Ok(self.context.clone())113 }114}115116#[derive(Trace, Clone)]117pub(crate) struct PackedContext {118 captures: Cc<Vec<Thunk<Val>>>,119 n_locals: u16,120}121impl PackedContext {122 pub fn enter(self, sup_this: SupThis, build: impl FnOnce(&LocalsFrame, &Context)) -> Context {123 let locals = LocalsFrame::new_once(self.n_locals);124 let val = Context(Cc::new(ContextInternal {125 captures: self.captures.clone(),126 locals,127 sup_this: Some(sup_this),128 }));129 build(&val.0.locals, &val);130 val131 }132}133#[derive(Trace, Clone, Educe, Debug)]134#[educe(PartialEq)]135pub(crate) struct PackedContextSupThis {136 #[educe(PartialEq(method = Cc::ptr_eq))]137 captures: Cc<Vec<Thunk<Val>>>,138 n_locals: u16,139 sup_this: Option<SupThis>,140}141impl PackedContextSupThis {142 pub fn enter(self, build: impl FnOnce(&LocalsFrame, &Context)) -> Context {143 let locals = LocalsFrame::new_once(self.n_locals);144 let val = Context(Cc::new(ContextInternal {145 captures: self.captures.clone(),146 locals,147 sup_this: self.sup_this,148 }));149 build(&val.0.locals, &val);150 val151 }152}153154impl Context {155 #[inline]156 pub fn slot(&self, slot: LSlot) -> Thunk<Val> {157 match slot {158 LSlot::Local(i) => self.local(i),159 LSlot::Capture(i) => self.capture(i),160 }161 }162 /// Read a local slot from the shared locals frame.163 ///164 /// # Panics165 /// If the slot has not yet been filled. The analyzer guarantees166 /// that slot indices are in range and that letrec setup completes167 /// before the first read. A panic indicates an analyzer/runtime168 /// invariant violation, not a user error.169 #[inline]170 pub fn local(&self, slot: LocalSlot) -> Thunk<Val> {171 match &*self.0.locals {172 LocalsFrame::Once1(cell) => {173 debug_assert_eq!(slot.0, 0, "Once1 only holds slot 0");174 cell.get().expect("local read before letrec init").clone()175 }176 LocalsFrame::Once(cells) => cells[slot.0 as usize]177 .get()178 .expect("local read before letrec init")179 .clone(),180 LocalsFrame::Iter(cells) => cells.slots[slot.0 as usize]181 .borrow()182 .as_ref()183 .expect("iter local read before iteration filled it")184 .clone(),185 }186 }187188 /// Read a captured slot from this closure's capture pack.189 #[inline]190 pub fn capture(&self, slot: CaptureSlot) -> Thunk<Val> {191 (*self.0.captures)[slot.0 as usize].clone()192 }193194 pub fn sup_this(&self) -> Option<&SupThis> {195 self.0.sup_this.as_ref()196 }197198 pub fn try_sup_this(&self) -> Result<SupThis> {199 self.0200 .sup_this201 .clone()202 .ok_or_else(|| error!(CantUseSelfSupOutsideOfObject))203 }204205 /// Build a root context: empty captures, externals filled into a206 /// fresh Once locals frame in declaration order. Used once at207 /// program entry to construct the context the analyzed root LIR208 /// runs against.209 pub(crate) fn root(externals: Vec<Thunk<Val>>) -> Self {210 let n: u16 = externals211 .len()212 .try_into()213 .expect("more than u16::MAX externals");214 let cells: Vec<OnceCell<Thunk<Val>>> = externals215 .into_iter()216 .map(|t| {217 let cell = OnceCell::new();218 cell.set(t).map_err(|_| ()).expect("fresh cell");219 cell220 })221 .collect();222 debug_assert_eq!(cells.len(), n as usize);223 let locals = Cc::new(LocalsFrame::Once(cells));224 Self(Cc::new(ContextInternal {225 captures: Cc::new(Vec::new()),226 locals,227 sup_this: None,228 }))229 }230231 pub(crate) fn pack_captures(&self, shape: &ClosureShape) -> PackedContext {232 PackedContext {233 captures: Cc::new(pack_captures(self, &shape.captures)),234 n_locals: shape.n_locals,235 }236 }237 pub(crate) fn pack_captures_sup_this(&self, shape: &ClosureShape) -> PackedContextSupThis {238 PackedContextSupThis {239 captures: Cc::new(pack_captures(self, &shape.captures)),240 n_locals: shape.n_locals,241 sup_this: self.0.sup_this.clone(),242 }243 }244245 pub(crate) fn enter_iter(246 parent: &Context,247 shape: &ClosureShape,248 cb: impl FnOnce(IterContext) -> Result<()>,249 ) -> Result<()> {250 let captures = Cc::new(pack_captures(parent, &shape.captures));251 let locals = IterFrame::new(shape.n_locals);252 cb(IterContext {253 context: Self(Cc::new(ContextInternal {254 captures,255 locals: Cc::new(LocalsFrame::Iter(locals)),256 sup_this: parent.0.sup_this.clone(),257 })),258 })259 }260261 pub(crate) fn enter_using(parent: &Context, shape: &ClosureShape) -> Self {262 debug_assert_eq!(shape.n_locals, 0);263 if shape.captures.is_empty() {264 if let LocalsFrame::Iter(i) = &*parent.0.locals {265 i.captured.set(true);266 }267 // Value never uses captures, thus evaluating it against the parent gives the same result268 return parent.clone();269 }270 let captures = Cc::new(pack_captures(parent, &shape.captures));271 Self(Cc::new(ContextInternal {272 captures,273 locals: parent.0.locals.clone(),274 sup_this: parent.0.sup_this.clone(),275 }))276 }277}278279fn pack_captures(parent: &Context, sources: &[LSlot]) -> Vec<Thunk<Val>> {280 sources.iter().map(|src| parent.slot(*src)).collect()281}282283pub struct InitialContextBuilder {284 externals: Vec<(IStr, LocalId)>,285 values: Vec<Thunk<Val>>,286 next_id: u32,287}288289impl InitialContextBuilder {290 pub(crate) fn new() -> Self {291 Self {292 externals: Vec::new(),293 values: Vec::new(),294 next_id: 0,295 }296 }297298 pub fn bind(&mut self, name: impl Into<IStr>, value: Thunk<Val>) {299 let name = name.into();300 let id = LocalId(self.next_id);301 self.next_id += 1;302 self.externals.push((name, id));303 self.values.push(value);304 }305306 pub(crate) fn build(self) -> (Vec<(IStr, LocalId)>, Vec<Thunk<Val>>) {307 (self.externals, self.values)308 }309}310311impl Default for InitialContextBuilder {312 fn default() -> Self {313 Self::new()314 }315}crates/jrsonnet-evaluator/src/dynamic.rsdiffbeforeafterboth--- a/crates/jrsonnet-evaluator/src/dynamic.rs
+++ b/crates/jrsonnet-evaluator/src/dynamic.rs
@@ -1,59 +1,6 @@
-use std::{cell::OnceCell, hash::Hasher, ptr::addr_of};
-
-use educe::Educe;
-use jrsonnet_gcmodule::{Cc, Trace};
-
-use crate::{Result, bail, error::ErrorKind::InfiniteRecursionDetected, val::ThunkValue};
-
-#[derive(Trace, Educe)]
-#[educe(Clone)]
-pub struct Pending<V: Trace + 'static>(pub Cc<OnceCell<V>>);
-impl<T: Trace + 'static> Pending<T> {
- pub fn new() -> Self {
- Self(Cc::new(OnceCell::new()))
- }
- pub fn new_filled(v: T) -> Self {
- let cell = OnceCell::new();
- let _ = cell.set(v);
- Self(Cc::new(cell))
- }
- /// # Panics
- /// If wrapper is filled already
- pub fn fill(self, value: T) {
- self.0
- .set(value)
- .map_err(|_| ())
- .expect("wrapper is filled already");
- }
-}
-impl<T: Trace + 'static + Clone> Pending<T> {
- /// # Panics
- /// If wrapper is not yet filled
- pub fn unwrap(&self) -> T {
- self.0.get().cloned().expect("pending was not filled")
- }
- pub fn try_get(&self) -> Option<T> {
- self.0.get().cloned()
- }
-}
+use std::{hash::Hasher, ptr::addr_of};
-impl<T: Trace + Clone> ThunkValue for Pending<T> {
- type Output = T;
-
- fn get(&self) -> Result<Self::Output> {
- let Some(value) = self.0.get() else {
- // TODO: Other error?
- bail!(InfiniteRecursionDetected);
- };
- Ok(value.clone())
- }
-}
-
-impl<T: Trace + 'static> Default for Pending<T> {
- fn default() -> Self {
- Self::new()
- }
-}
+use jrsonnet_gcmodule::Cc;
pub fn identity_hash<T, H: Hasher>(v: &Cc<T>, hasher: &mut H) {
hasher.write_usize(addr_of!(**v) as usize);
crates/jrsonnet-evaluator/src/error.rsdiffbeforeafterboth--- a/crates/jrsonnet-evaluator/src/error.rs
+++ b/crates/jrsonnet-evaluator/src/error.rs
@@ -10,6 +10,7 @@
use crate::{
ObjValue, ResolvePathOwned,
+ analyze::Diagnostic,
function::{CallLocation, FunctionSignature, ParamName},
stdlib::format::FormatError,
typed::TypeLocError,
@@ -112,12 +113,14 @@
CantUseSelfSupOutsideOfObject,
#[error("static analysis errors: {}", .0.iter().map(|d| d.message.as_str()).collect::<Vec<_>>().join("; "))]
- StaticAnalysisError(Vec<crate::analyze::Diagnostic>),
+ StaticAnalysisError(Vec<Diagnostic>),
#[error("no super found")]
NoSuperFound,
#[error("for loop can only iterate over arrays")]
InComprehensionCanOnlyIterateOverArray,
+ #[error("(should not be visible) eager compspec evaluation failed due to captured context")]
+ EagerCompspecCaptured,
#[error("array out of bounds: {0} is not within [0,{1})")]
ArrayBoundsError(isize, u32),
@@ -394,12 +397,5 @@
};
($l:literal$(, $($tt:tt)*)?) => {
<$crate::error::Error as From<$crate::error::ErrorKind>>::from($crate::error::ErrorKind::RuntimeError($crate::jrsonnet_macros::format_istr!($l$(, $($tt)*)?)).into())
- };
-}
-
-#[macro_export]
-macro_rules! runtime_error {
- ($l:literal$(, $($tt:tt)*)?) => {
- $crate::error::Error::from($crate::error::ErrorKind::RuntimeError($crate::jrsonnet_macros::format_istr!($l$(, $($tt)*)?)))
};
}
crates/jrsonnet-evaluator/src/evaluate/compspec.rsdiffbeforeafterboth--- a/crates/jrsonnet-evaluator/src/evaluate/compspec.rs
+++ b/crates/jrsonnet-evaluator/src/evaluate/compspec.rs
@@ -3,16 +3,19 @@
use jrsonnet_types::ValType;
use super::{
- destructure::{self, evaluate_locals, evaluate_locals_unbound},
+ destructure::{destruct, evaluate_locals_unbound, fill_letrec_binds},
evaluate_field_member_static, evaluate_field_member_unbound,
};
use crate::{
- Context, ContextBuilder, ObjValue, ObjValueBuilder, Pending, Result, Thunk, Val,
- analyze::{LArrComp, LBind, LCompSpec, LDestruct, LExpr, LFieldMember, LObjComp, LocalId},
+ Context, ObjValue, ObjValueBuilder, Result, Thunk, Val,
+ analyze::{
+ ClosureShape, LArrComp, LBind, LCompSpec, LDestruct, LExpr, LFieldMember, LObjComp,
+ LocalSlot,
+ },
arr::ArrValue,
bail,
error::ErrorKind::*,
- evaluate::evaluate,
+ evaluate::{evaluate, evaluate_trivial},
};
trait CompCollector {
@@ -22,6 +25,7 @@
struct EagerArrCollector<'a> {
out: &'a mut Vec<Val>,
+ value_shape: &'a ClosureShape,
value: &'a LExpr,
}
impl CompCollector for EagerArrCollector<'_> {
@@ -29,13 +33,23 @@
self.out.reserve(size_hint);
}
fn collect(&mut self, ctx: Context) -> Result<()> {
- self.out.push(evaluate(ctx, self.value)?);
+ if let Some(v) = evaluate_trivial(self.value) {
+ self.out.push(v);
+ return Ok(());
+ }
+ if let LExpr::Slot(slot) = self.value {
+ self.out.push(ctx.slot(*slot).evaluate()?);
+ return Ok(());
+ }
+ let env = Context::enter_using(&ctx, self.value_shape);
+ self.out.push(evaluate(env, self.value)?);
Ok(())
}
}
struct LazyArrCollector<'a> {
out: &'a mut Vec<Thunk<Val>>,
+ value_shape: &'a ClosureShape,
value: &'a Rc<LExpr>,
}
impl CompCollector for LazyArrCollector<'_> {
@@ -43,14 +57,24 @@
self.out.reserve(size_hint);
}
fn collect(&mut self, ctx: Context) -> Result<()> {
+ if let Some(v) = evaluate_trivial(self.value) {
+ self.out.push(Thunk::evaluated(v));
+ return Ok(());
+ }
+ if let LExpr::Slot(slot) = self.value.as_ref() {
+ self.out.push(ctx.slot(*slot));
+ return Ok(());
+ }
+ let env = Context::enter_using(&ctx, self.value_shape);
let value_expr = self.value.clone();
- self.out.push(Thunk!(move || evaluate(ctx, &value_expr)));
+ self.out.push(Thunk!(move || evaluate(env, &value_expr)));
Ok(())
}
}
struct ObjCompCollectorStatic<'a> {
builder: &'a mut ObjValueBuilder,
+ frame_shape: &'a ClosureShape,
locals: &'a [LBind],
field: &'a LFieldMember,
}
@@ -59,15 +83,23 @@
self.builder.reserve_fields(guaranteed);
}
fn collect(&mut self, inner_ctx: Context) -> Result<()> {
- let value_ctx = evaluate_locals(inner_ctx.clone(), self.locals);
+ // Build the object's A-frame fresh per iteration: captures from
+ // the comp's iter ctx, locals = `this` (slot 0, unfilled in the
+ // static path) + member-locals via letrec.
+ let value_ctx = inner_ctx
+ .pack_captures_sup_this(self.frame_shape)
+ .enter(|fill, ctx| {
+ fill_letrec_binds(fill, &ctx, self.locals);
+ });
evaluate_field_member_static(self.builder, inner_ctx, value_ctx, self.field)
}
}
struct ObjCompCollectorUnbound<'a> {
builder: &'a mut ObjValueBuilder,
+ frame_shape: Rc<ClosureShape>,
locals: Rc<Vec<LBind>>,
- this_id: Option<LocalId>,
+ this_slot: Option<LocalSlot>,
field: &'a LFieldMember,
}
impl CompCollector for ObjCompCollectorUnbound<'_> {
@@ -75,7 +107,12 @@
self.builder.reserve_fields(guaranteed);
}
fn collect(&mut self, inner_ctx: Context) -> Result<()> {
- let uctx = evaluate_locals_unbound(inner_ctx.clone(), self.locals.clone(), self.this_id);
+ let uctx = evaluate_locals_unbound(
+ &inner_ctx,
+ &self.frame_shape,
+ self.this_slot,
+ self.locals.clone(),
+ );
evaluate_field_member_unbound(self.builder, inner_ctx, uctx, self.field)
}
}
@@ -100,8 +137,9 @@
0,
&mut ObjCompCollectorUnbound {
builder: &mut builder,
+ frame_shape: comp.frame_shape.clone(),
locals: comp.locals.clone(),
- this_id: comp.this,
+ this_slot: comp.this,
field: &comp.field,
},
)?;
@@ -114,6 +152,7 @@
0,
&mut ObjCompCollectorStatic {
builder: &mut builder,
+ frame_shape: &comp.frame_shape,
locals: &comp.locals,
field: &comp.field,
},
@@ -126,7 +165,9 @@
pub fn evaluate_arr_comp(ctx: Context, comp: &LArrComp) -> Result<Val> {
let cached_overs = cache_overs(&ctx, &comp.compspecs)?;
- // In eager evaluation, Context is not captured, thus updates in CoW fashion will likely to success
+ // Eager fast-path: when the comp has only `if` and `for { destruct: Full(_) }`
+ // specs, allocate one Iter A-frame per for-spec and re-set the slot
+ // per iteration as long as the frame's refcount stays at 1.
'eager: {
let mut out = Vec::new();
@@ -147,6 +188,7 @@
0,
&mut EagerArrCollector {
out: &mut out,
+ value_shape: &comp.value_shape,
value: &comp.value,
},
)
@@ -166,6 +208,7 @@
0,
&mut LazyArrCollector {
out: &mut items,
+ value_shape: &comp.value_shape,
value: &comp.value,
},
)?;
@@ -220,7 +263,12 @@
evaluate_compspecs_eager(ctx, specs, cached_overs, idx + 1, 0, collector)?;
}
}
- LCompSpec::For { destruct, over, .. } => {
+ LCompSpec::For {
+ frame_shape,
+ destruct,
+ over,
+ ..
+ } => {
let arr = if let Some(cached) = &cached_overs[idx] {
cached.clone()
} else {
@@ -232,21 +280,24 @@
};
let inner_reserve = guaranteed_reserve.max(1) * arr.len() as usize;
match destruct {
- LDestruct::Full(id) => {
- let id = *id;
- let mut inner_ctx = ContextBuilder::extend(ctx, 1).build();
- for (i, item) in arr.iter().enumerate() {
- // TODO: reuse one ContextBuilder for full evaluate_compspecs pipeline
- inner_ctx.cow_fill_binding(id, Thunk::evaluated(item?));
- evaluate_compspecs_eager(
- inner_ctx.clone(),
- specs,
- cached_overs,
- idx + 1,
- if i == 0 { inner_reserve } else { 0 },
- collector,
- )?;
- }
+ LDestruct::Full(slot) => {
+ Context::enter_iter(&ctx, frame_shape, |it| {
+ for (i, item) in arr.iter().enumerate() {
+ let item = item?;
+ let ctx = it.create(|f| {
+ f.set(*slot, Thunk::evaluated(item));
+ })?;
+ evaluate_compspecs_eager(
+ ctx,
+ specs,
+ cached_overs,
+ idx + 1,
+ if i == 0 { inner_reserve } else { 0 },
+ collector,
+ )?;
+ }
+ Ok(())
+ })?;
}
// TODO: Should not be eager? CoW won't work here
#[cfg(feature = "exp-destruct")]
@@ -283,7 +334,12 @@
evaluate_compspecs(ctx, specs, cached_overs, idx + 1, 0, collector)?;
}
}
- LCompSpec::For { destruct, over, .. } => {
+ LCompSpec::For {
+ frame_shape,
+ destruct: dst,
+ over,
+ ..
+ } => {
let arr = if let Some(cached) = &cached_overs[idx] {
cached.clone()
} else {
@@ -295,16 +351,10 @@
};
let inner_reserve = guaranteed_reserve.max(1) * arr.len() as usize;
for (i, item) in arr.iter().enumerate() {
- let item_val = item?;
- let mut inner_builder = ContextBuilder::extend(ctx.clone(), 1);
- let fctx = Pending::new();
- destructure::destruct(
- destruct,
- Thunk::evaluated(item_val),
- fctx.clone(),
- &mut inner_builder,
- );
- let inner_ctx = inner_builder.build().into_future(fctx);
+ let item = item?;
+ let inner_ctx = ctx.pack_captures_sup_this(frame_shape).enter(|fill, ctx| {
+ destruct(dst, fill, Thunk::evaluated(item), &ctx);
+ });
evaluate_compspecs(
inner_ctx,
specs,
crates/jrsonnet-evaluator/src/evaluate/destructure.rsdiffbeforeafterboth--- a/crates/jrsonnet-evaluator/src/evaluate/destructure.rs
+++ b/crates/jrsonnet-evaluator/src/evaluate/destructure.rs
@@ -3,8 +3,10 @@
use jrsonnet_gcmodule::Trace;
use crate::{
- Context, ContextBuilder, Pending, Result, SupThis, Thunk, Unbound, Val,
- analyze::{LBind, LDestruct, LDestructField, LDestructRest, LExpr, LocalId},
+ Context, LocalsFrame, PackedContext, Result, SupThis, Thunk, Unbound, Val,
+ analyze::{
+ ClosureShape, LBind, LDestruct, LDestructField, LDestructRest, LExpr, LLocalExpr, LocalSlot,
+ },
bail,
evaluate::evaluate,
};
@@ -15,9 +17,9 @@
rest: Option<&LDestructRest>,
end: &[LDestruct],
+ fill: &LocalsFrame,
value: Thunk<Val>,
- fctx: Pending<Context>,
- builder: &mut ContextBuilder,
+ a_ctx: &Context,
) {
let min_len = start.len() + end.len();
let has_rest = rest.is_some();
@@ -44,19 +46,19 @@
let full = full.clone();
destruct(
d,
+ fill,
Thunk!(move || Ok(full.evaluate()?.get(i as u32)?.expect("length is checked"))),
- fctx.clone(),
- builder,
+ a_ctx,
);
}
let start_len = start.len() as u32;
let end_len = end.len() as u32;
- if let Some(crate::analyze::LDestructRest::Keep(id)) = rest {
+ if let Some(LDestructRest::Keep(slot)) = rest {
let full = full.clone();
- builder.bind(
- *id,
+ fill.set(
+ *slot,
Thunk!(move || {
let full = full.evaluate()?;
let to = full.len() - end_len;
@@ -73,14 +75,14 @@
let full = full.clone();
destruct(
d,
+ fill,
Thunk!(move || {
let full = full.evaluate()?;
Ok(full
.get(full.len() - end_len + i as u32)?
.expect("length is checked"))
}),
- fctx.clone(),
- builder,
+ a_ctx,
);
}
}
@@ -90,9 +92,9 @@
fields: &[LDestructField],
rest: Option<&LDestructRest>,
+ fill: &LocalsFrame,
value: Thunk<Val>,
- fctx: Pending<Context>,
- builder: &mut ContextBuilder,
+ a_ctx: &Context,
) {
use jrsonnet_interner::IStr;
use rustc_hash::FxHashSet;
@@ -124,10 +126,10 @@
Ok(obj)
});
- if let Some(crate::analyze::LDestructRest::Keep(id)) = rest {
+ if let Some(LDestructRest::Keep(slot)) = rest {
let full = full.clone();
- builder.bind(
- *id,
+ fill.set(
+ *slot,
Thunk!(move || {
let full = full.evaluate()?;
let mut out = ObjValueBuilder::new();
@@ -140,121 +142,100 @@
for field in fields {
let field_name = field.name.clone();
- let default: Option<(Pending<Context>, Rc<LExpr>)> =
- field.default.as_ref().map(|e| (fctx.clone(), e.clone()));
+ let default_thunk: Option<Thunk<Val>> = field
+ .default
+ .as_ref()
+ .map(|(shape, expr)| build_b_thunk(a_ctx, shape, expr.clone()));
+
let field_full = full.clone();
let value_thunk = Thunk!(move || {
let obj = field_full.evaluate()?;
obj.get(field_name)?.map_or_else(
- || {
- let (fctx, expr) = default.as_ref().expect("shape is checked");
- evaluate(fctx.unwrap(), expr)
- },
+ || default_thunk.as_ref().expect("shape is checked").evaluate(),
Ok,
)
});
if let Some(into) = &field.into {
- destruct(into, value_thunk, fctx.clone(), builder);
+ destruct(into, fill, value_thunk, a_ctx);
} else {
unreachable!("analyzer lowers object-destruct shorthands into `into`");
}
}
}
-/// Bind a pre-built thunk to an [`LDestruct`] pattern, inserting one
-/// binding per [`LocalId`] the pattern introduces.
-///
-/// `fctx` is needed for object-destruct defaults (feature `exp-destruct`).
#[allow(unused_variables)]
-pub fn destruct(
- d: &LDestruct,
- value: Thunk<Val>,
- fctx: Pending<Context>,
- builder: &mut ContextBuilder,
-) {
+pub fn destruct(d: &LDestruct, fill: &LocalsFrame, value: Thunk<Val>, a_ctx: &Context) {
match d {
- LDestruct::Full(id) => builder.bind(*id, value),
+ LDestruct::Full(slot) => fill.set(*slot, value),
#[cfg(feature = "exp-destruct")]
LDestruct::Skip => {}
#[cfg(feature = "exp-destruct")]
LDestruct::Array { start, rest, end } => {
- destruct_array(start, rest.as_ref(), end, value, fctx, builder)
+ destruct_array(start, rest.as_ref(), end, fill, value, a_ctx)
}
#[cfg(feature = "exp-destruct")]
- LDestruct::Object { fields, rest } => {
- destruct_object(fields, rest.as_ref(), value, fctx, builder)
- }
+ LDestruct::Object { fields, rest } => destruct_object(fields, rest.as_ref(), fill, value, a_ctx),
}
}
-/// Bind one [`LBind`] as a lazy thunk that evaluates in the given
-/// future context. Mirrors the old `evaluate_dest` — one entry per
-/// binding in a `local … ;` frame.
-pub fn evaluate_dest(bind: &LBind, fctx: Pending<Context>, builder: &mut ContextBuilder) {
- let value = bind.value.clone();
- let fctx_clone = fctx.clone();
- let thunk = Thunk!(move || {
- let ctx = fctx_clone.unwrap();
- evaluate(ctx, &value)
- });
- destruct(&bind.destruct, thunk, fctx, builder);
+pub fn build_b_thunk(a_ctx: &Context, shape: &ClosureShape, expr: Rc<LExpr>) -> Thunk<Val> {
+ let env = Context::enter_using(a_ctx, shape);
+ Thunk!(move || evaluate(env, &expr))
+}
+pub fn build_b_thunk_uno(a_ctx: &Context, shape: Rc<(ClosureShape, LExpr)>) -> Thunk<Val> {
+ let env = Context::enter_using(a_ctx, &shape.0);
+ Thunk!(move || evaluate(env, &shape.1))
}
-/// Bind each LBind's value as a lazy thunk. Mutually recursive locals
-/// resolve lazily through the shared Pending<Context>.
-pub fn evaluate_locals(parent: Context, binds: &[LBind]) -> Context {
- if binds.is_empty() {
- return parent;
- }
- let fctx = Context::new_future();
- let mut builder =
- ContextBuilder::extend(parent, binds.iter().map(|b| b.destruct.ids().len()).sum());
+pub fn fill_letrec_binds(fill: &LocalsFrame, ctx: &Context, binds: &[LBind]) {
for bind in binds {
- evaluate_dest(bind, fctx.clone(), &mut builder);
+ let value_thunk = build_b_thunk(ctx, &bind.value_shape, bind.value.clone());
+ destruct(&bind.destruct, fill, value_thunk, ctx);
}
- builder.build().into_future(fctx)
}
+pub fn evaluate_local_expr(parent: Context, l: &LLocalExpr) -> Result<Val> {
+ let ctx = parent
+ .pack_captures_sup_this(&l.frame_shape)
+ .enter(|fill, ctx| {
+ fill_letrec_binds(fill, ctx, &l.binds);
+ });
+ evaluate(ctx, &l.body)
+}
+
pub trait CloneableUnbound<T>: Unbound<Bound = T> + Clone {}
impl<V, T> CloneableUnbound<T> for V where V: Unbound<Bound = T> + Clone {}
pub fn evaluate_locals_unbound(
- fctx: Context,
+ outer: &Context,
+ frame_shape: &ClosureShape,
+ this_slot: Option<LocalSlot>,
locals: Rc<Vec<LBind>>,
- this_id: Option<LocalId>,
) -> impl CloneableUnbound<Context> {
#[derive(Trace, Clone)]
struct UnboundLocals {
- fctx: Context,
+ captures: PackedContext,
+ this_slot: Option<LocalSlot>,
locals: Rc<Vec<LBind>>,
- this_id: Option<LocalId>,
}
impl Unbound for UnboundLocals {
type Bound = Context;
fn bind(&self, sup_this: SupThis) -> Result<Context> {
- let parent = self.fctx.clone();
-
- let fctx = Context::new_future();
- let mut builder = ContextBuilder::extend(
- parent,
- self.locals.iter().map(|b| b.destruct.ids().len()).sum(),
- );
- for b in self.locals.iter() {
- evaluate_dest(b, fctx.clone(), &mut builder);
- }
- if let Some(this_id) = self.this_id {
- builder.bind(this_id, Thunk::evaluated(Val::Obj(sup_this.this().clone())));
- }
- let ctx = builder.build_sup_this(sup_this).into_future(fctx);
- Ok(ctx)
+ Ok(self.captures.clone().enter(sup_this, |fill, ctx| {
+ if let Some(slot) = self.this_slot {
+ let this_obj = ctx.sup_this().expect("sup_this set above").this().clone();
+ fill.set(slot, Thunk::evaluated(Val::Obj(this_obj)));
+ }
+ fill_letrec_binds(fill, ctx, &self.locals);
+ }))
}
}
UnboundLocals {
- fctx,
+ captures: outer.pack_captures(frame_shape),
+ this_slot,
locals,
- this_id,
}
}
crates/jrsonnet-evaluator/src/evaluate/mod.rsdiffbeforeafterboth--- a/crates/jrsonnet-evaluator/src/evaluate/mod.rs
+++ b/crates/jrsonnet-evaluator/src/evaluate/mod.rs
@@ -7,21 +7,22 @@
use self::{
compspec::{evaluate_arr_comp, evaluate_obj_comp},
- destructure::{evaluate_locals, evaluate_locals_unbound},
+ destructure::{build_b_thunk_uno, evaluate_local_expr, evaluate_locals_unbound},
operator::evaluate_binary_op_special,
};
use crate::{
Context, Error, ObjValue, ObjValueBuilder, ObjectAssertion, Result, ResultExt as _, SupThis,
Unbound, Val,
analyze::{
- LArgsDesc, LAssertStmt, LExpr, LFieldMember, LFieldName, LFunction, LIndexPart, LObjBody,
- LObjMembers,
+ ClosureShape, LArgsDesc, LAssertStmt, LExpr, LFieldMember, LFieldName, LFunction,
+ LIndexPart, LObjAsserts, LObjBody, LObjMembers, LSlot,
},
- bail,
+ arr::ArrValue,
+ bail, error,
error::{ErrorKind::*, suggest_object_fields},
- evaluate::operator::evaluate_unary_op,
+ evaluate::{destructure::fill_letrec_binds, operator::evaluate_unary_op},
function::{CallLocation, FuncDesc, FuncVal, prepared::PreparedFuncVal},
- in_frame, runtime_error,
+ in_frame,
typed::FromUntyped as _,
val::{CachedUnbound, Thunk},
with_state,
@@ -62,11 +63,10 @@
})
}
-/// Evaluate a method definition.
pub fn evaluate_method(ctx: Context, name: IStr, func: &Rc<LFunction>) -> Val {
Val::Func(FuncVal::Normal(Cc::new(FuncDesc {
name,
- ctx,
+ body_captures: ctx.pack_captures_sup_this(&func.body_shape),
func: func.clone(),
})))
}
@@ -91,6 +91,15 @@
}
pub fn evaluate_thunk(ctx: Context, expr: Rc<LExpr>, tailstrict: bool) -> Result<Thunk<Val>> {
+ match &*expr {
+ LExpr::Slot(LSlot::Local(i)) => return Ok(ctx.local(*i)),
+ LExpr::Slot(LSlot::Capture(i)) => return Ok(ctx.capture(*i)),
+ _ => {
+ if let Some(v) = evaluate_trivial(&expr) {
+ return Ok(Thunk::evaluated(v));
+ }
+ }
+ }
Ok(if tailstrict {
Thunk::evaluated(evaluate(ctx, &expr)?)
} else {
@@ -106,40 +115,21 @@
}
}
-pub fn evaluate_named(name: &IStr, ctx: Context, expr: &LExpr) -> Result<Val> {
- if let LExpr::Function(f) = &expr {
- return Ok(evaluate_method(
- ctx,
- f.name.clone().unwrap_or_else(|| name.clone()),
- f,
- ));
- }
- evaluate(ctx, expr)
-}
-
pub fn evaluate(ctx: Context, expr: &LExpr) -> Result<Val> {
Ok(match expr {
LExpr::Null => Val::Null,
LExpr::Bool(b) => Val::Bool(*b),
LExpr::Str(s) => Val::string(s.clone()),
LExpr::Num(n) => Val::Num(*n),
- LExpr::Local(id) => {
- let Some(thunk) = ctx.binding(*id) else {
- bail!("should not happen: unbound local {id:?}");
- };
- thunk.evaluate()?
- }
+ LExpr::Slot(slot) => ctx.slot(*slot).evaluate()?,
LExpr::BadLocal(name) => panic!("unresolvable reference: {name}"),
- LExpr::Arr(items) => Val::Arr(crate::arr::ArrValue::expr(ctx, items.clone())),
+ LExpr::Arr { shape, items } => Val::Arr(ArrValue::expr(ctx, shape, items.clone())),
LExpr::UnaryOp(op, value) => {
let value = evaluate(ctx, value)?;
evaluate_unary_op(*op, &value)?
}
LExpr::BinaryOp { lhs, op, rhs } => evaluate_binary_op_special(ctx, lhs, *op, rhs)?,
- LExpr::LocalExpr { binds, body } => {
- let ctx = evaluate_locals(ctx, binds);
- evaluate(ctx, body)?
- }
+ LExpr::LocalExpr(local_expr) => evaluate_local_expr(ctx, local_expr)?,
LExpr::IfElse {
cond,
cond_then,
@@ -176,6 +166,7 @@
func.name.clone().unwrap_or_else(names::anonymous),
func,
),
+ LExpr::IdentityFunction => Val::Func(FuncVal::identity()),
LExpr::Apply {
applicable,
args,
@@ -240,8 +231,7 @@
let n = v.as_num().ok_or_else(|| -> crate::Error {
TypeMismatch("slice step", vec![ValType::Num], v.value_type()).into()
})?;
- BoundedUsize::new(n as usize)
- .ok_or_else(|| runtime_error!("slice step must be >= 1"))
+ BoundedUsize::new(n as usize).ok_or_else(|| error!("slice step must be >= 1"))
})
.transpose()?;
Val::from(indexable.slice(start, end, step)?)
@@ -278,7 +268,32 @@
bail!(OnlyFunctionsCanBeCalledGot(func_val.value_type()))
};
+ if func.is_identity() && args.names.is_empty() && args.unnamed.len() == 1 {
+ return evaluate_thunk(ctx, args.unnamed[0].clone(), tailstrict)?.evaluate();
+ }
+
let name = func.name();
+
+ if args.names.is_empty() && args.unnamed.len() == 1 && func.params().len() == 1 {
+ use crate::function::prepared::PreparedCall;
+ let prepared_inline = PreparedCall::empty();
+ let arg = evaluate_thunk(ctx, args.unnamed[0].clone(), tailstrict)?;
+ let arg_slice = std::slice::from_ref(&arg);
+ return in_frame(
+ loc,
+ || format!("function <{name}> call"),
+ || {
+ func.evaluate_prepared(
+ &prepared_inline,
+ CallLocation::native(),
+ arg_slice,
+ &[],
+ tailstrict,
+ )
+ },
+ );
+ }
+
let unnamed = args
.unnamed
.iter()
@@ -286,6 +301,26 @@
.map(|e| evaluate_thunk(ctx.clone(), e, tailstrict))
.collect::<Result<Vec<_>>>()?;
+ // Fast path: positional-only multi-arg call fully covering the
+ // params, no defaults.
+ if args.names.is_empty() && unnamed.len() == func.params().len() {
+ use crate::function::prepared::PreparedCall;
+ let prepared_inline = PreparedCall::empty();
+ return in_frame(
+ loc,
+ || format!("function <{name}> call"),
+ || {
+ func.evaluate_prepared(
+ &prepared_inline,
+ CallLocation::native(),
+ &unnamed,
+ &[],
+ tailstrict,
+ )
+ },
+ );
+ }
+
let named = args
.values
.iter()
@@ -302,7 +337,7 @@
}
fn evaluate_index(ctx: Context, indexable: &LExpr, parts: &[LIndexPart]) -> Result<Val> {
- let mut value = if let LExpr::Super = indexable {
+ let mut value = if matches!(indexable, LExpr::Super) {
let sup_this = ctx.try_sup_this()?;
// First part must be evaluated to get the super field name
if parts.is_empty() {
@@ -422,13 +457,15 @@
#[derive(Trace)]
struct UnboundValue<B: Trace> {
uctx: B,
- value: Rc<LExpr>,
+ value: Rc<(ClosureShape, LExpr)>,
name: IStr,
}
impl<B: Unbound<Bound = Context>> Unbound for UnboundValue<B> {
type Bound = Val;
fn bind(&self, sup_this: SupThis) -> Result<Val> {
- evaluate(self.uctx.bind(sup_this)?, &self.value)
+ let a_ctx = self.uctx.bind(sup_this)?;
+ let b_ctx = Context::enter_using(&a_ctx, &self.value.0);
+ evaluate(b_ctx, &self.value.1)
}
}
@@ -468,12 +505,12 @@
return Ok(());
};
- let value = value.clone();
+ let thunk = build_b_thunk_uno(&value_ctx, value.clone());
builder
.field(name)
.with_add(*plus)
.with_visibility(*visibility)
- .try_thunk(Thunk!(move || { evaluate(value_ctx, &value) }))?;
+ .try_thunk(thunk)?;
Ok(())
}
@@ -491,34 +528,33 @@
if needs_unbound {
let uctx = CachedUnbound::new(evaluate_locals_unbound(
- ctx.clone(),
- members.locals.clone(),
+ &ctx,
+ &members.frame_shape,
members.this,
+ members.locals.clone(),
));
for field in &members.fields {
evaluate_field_member_unbound(&mut builder, ctx.clone(), uctx.clone(), field)?;
}
- if !members.asserts.is_empty() {
+ if let Some(asserts_block) = &members.asserts {
builder.assert(evaluate_object_assertions_unbound(
uctx,
- members.asserts.clone(),
+ asserts_block.clone(),
));
}
} else {
- let field_ctx = ctx;
- let value_ctx = evaluate_locals(field_ctx.clone(), &members.locals);
+ let a_ctx = ctx
+ .pack_captures_sup_this(&members.frame_shape)
+ .enter(|fill, ctx| {
+ fill_letrec_binds(fill, &ctx, &members.locals);
+ });
for field in &members.fields {
- evaluate_field_member_static(
- &mut builder,
- field_ctx.clone(),
- value_ctx.clone(),
- field,
- )?;
+ evaluate_field_member_static(&mut builder, ctx.clone(), a_ctx.clone(), field)?;
}
- if !members.asserts.is_empty() {
+ if let Some(asserts_block) = &members.asserts {
builder.assert(evaluate_object_assertions_static(
- value_ctx,
- members.asserts.clone(),
+ a_ctx,
+ asserts_block.clone(),
));
}
}
@@ -529,7 +565,7 @@
pub fn evaluate_assert(ctx: Context, assertion: &LAssertStmt) -> Result<()> {
let LAssertStmt { cond, message } = assertion;
let assertion_result = in_frame(
- CallLocation::native(),
+ CallLocation::new(&cond.span),
|| "assertion condition".to_owned(),
|| bool::from_untyped(evaluate(ctx.clone(), cond)?),
)?;
@@ -550,18 +586,19 @@
fn evaluate_object_assertions_unbound<B: Unbound<Bound = Context>>(
uctx: B,
- asserts: Rc<Vec<LAssertStmt>>,
+ asserts: Rc<LObjAsserts>,
) -> impl ObjectAssertion {
#[derive(Trace)]
struct ObjectAssert<B: Trace> {
uctx: B,
- asserts: Rc<Vec<LAssertStmt>>,
+ asserts: Rc<LObjAsserts>,
}
impl<B: Unbound<Bound = Context>> ObjectAssertion for ObjectAssert<B> {
fn run(&self, sup_this: SupThis) -> Result<()> {
- let ctx = self.uctx.bind(sup_this)?;
- for assert in &*self.asserts {
- evaluate_assert(ctx.clone(), assert)?;
+ let a_ctx = self.uctx.bind(sup_this)?;
+ let assert_env = Context::enter_using(&a_ctx, &self.asserts.shape);
+ for assert in &self.asserts.asserts {
+ evaluate_assert(assert_env.clone(), assert)?;
}
Ok(())
}
@@ -569,21 +606,25 @@
ObjectAssert { uctx, asserts }
}
fn evaluate_object_assertions_static(
- ctx: Context,
- asserts: Rc<Vec<LAssertStmt>>,
+ a_ctx: Context,
+ asserts: Rc<LObjAsserts>,
) -> impl ObjectAssertion {
#[derive(Trace)]
struct ObjectAssert {
- ctx: Context,
- asserts: Rc<Vec<LAssertStmt>>,
+ assert_env: Context,
+ asserts: Rc<LObjAsserts>,
}
impl ObjectAssertion for ObjectAssert {
fn run(&self, _sup_this: SupThis) -> Result<()> {
- for assert in &*self.asserts {
- evaluate_assert(self.ctx.clone(), assert)?;
+ for assert in &self.asserts.asserts {
+ evaluate_assert(self.assert_env.clone(), assert)?;
}
Ok(())
}
}
- ObjectAssert { ctx, asserts }
+ let assert_env = Context::enter_using(&a_ctx, &asserts.shape);
+ ObjectAssert {
+ assert_env,
+ asserts,
+ }
}
crates/jrsonnet-evaluator/src/function/mod.rsdiffbeforeafterboth--- a/crates/jrsonnet-evaluator/src/function/mod.rs
+++ b/crates/jrsonnet-evaluator/src/function/mod.rs
@@ -11,9 +11,12 @@
prepared::{PreparedCall, parse_prepared_builtin_call},
};
use crate::{
- Context, ContextBuilder, Result, Thunk, Val,
- analyze::{LDestruct, LExpr, LFunction},
- evaluate::{destructure::destruct, ensure_sufficient_stack, evaluate, evaluate_trivial},
+ PackedContextSupThis, Result, Thunk, Val,
+ analyze::LFunction,
+ evaluate::{
+ destructure::{build_b_thunk, destruct},
+ ensure_sufficient_stack, evaluate, evaluate_trivial,
+ },
function::builtin::BuiltinFunc,
};
@@ -56,16 +59,7 @@
/// { a() = ... }
/// ```
pub name: IStr,
- /// Context, in which this function was evaluated.
- ///
- /// # Example
- /// In
- /// ```jsonnet
- /// local a = 2;
- /// function() ...
- /// ```
- /// context will contain `a`.
- pub ctx: Context,
+ pub(crate) body_captures: PackedContextSupThis,
#[educe(PartialEq(method = Rc::ptr_eq))]
pub func: Rc<LFunction>,
@@ -82,44 +76,34 @@
named: &[Thunk<Val>],
prepared: &PreparedCall,
) -> Result<Val> {
- let has_defaults = !prepared.defaults().is_empty();
- let mut builder = ContextBuilder::extend(self.ctx.clone(), self.func.params.len());
-
- let fctx = Context::new_future();
- for (param_idx, thunk) in unnamed.iter().enumerate() {
- destruct(
- &self.func.params[param_idx].destruct,
- thunk.clone(),
- fctx.clone(),
- &mut builder,
- );
- }
-
- for &(param_idx, arg_idx) in prepared.named() {
- destruct(
- &self.func.params[param_idx].destruct,
- named[arg_idx].clone(),
- fctx.clone(),
- &mut builder,
- );
- }
+ let body_ctx = self.body_captures.clone().enter(|fill, ctx| {
+ // Place each provided arg-thunk into its destructured slots.
+ for (param_idx, thunk) in unnamed.iter().enumerate() {
+ destruct(
+ &self.func.params[param_idx].destruct,
+ fill,
+ thunk.clone(),
+ &ctx,
+ );
+ }
+ for &(param_idx, arg_idx) in prepared.named() {
+ destruct(
+ &self.func.params[param_idx].destruct,
+ fill,
+ named[arg_idx].clone(),
+ &ctx,
+ );
+ }
- if has_defaults {
for ¶m_idx in prepared.defaults() {
let param = &self.func.params[param_idx];
- if let Some(default_expr) = ¶m.default {
- let default_expr = default_expr.clone();
- let fctxc = fctx.clone();
- let thunk = Thunk!(move || {
- let ctx = fctxc.unwrap();
- evaluate(ctx, &default_expr)
- });
- destruct(¶m.destruct, thunk, fctx.clone(), &mut builder);
- }
+ let (shape, expr) = param.default.as_ref().expect("default exists");
+ let thunk = build_b_thunk(&ctx, shape, expr.clone());
+ destruct(¶m.destruct, fill, thunk, &ctx);
}
- };
- let ctx = builder.build().into_future(fctx);
- ensure_sufficient_stack(|| evaluate(ctx, &self.func.body))
+ });
+
+ ensure_sufficient_stack(|| evaluate(body_ctx, &self.func.body))
}
pub fn evaluate_trivial(&self) -> Option<Val> {
@@ -157,6 +141,10 @@
Self::Builtin(BuiltinFunc::new(builtin))
}
+ pub fn identity() -> Self {
+ Self::builtin(builtin_id {})
+ }
+
pub fn params(&self) -> FunctionSignature {
match self {
Self::Builtin(i) => i.params(),
@@ -193,27 +181,12 @@
}
/// Is this function an identity function.
- ///
- /// Currently only works for builtin `std.id`, aka `Self::Id` value, and `function(x) x`.
///
/// This function should only be used for optimization, not for the conditional logic, i.e code should work with syntetic identity function too
pub fn is_identity(&self) -> bool {
match self {
Self::Builtin(b) => b.as_any().downcast_ref::<builtin_id>().is_some(),
- Self::Normal(desc) => {
- if desc.func.params.len() != 1 {
- return false;
- }
- let param = &desc.func.params[0];
- if param.default.is_some() {
- return false;
- }
- #[allow(irrefutable_let_patterns, reason = "refutable with exp-destruct")]
- let LDestruct::Full(id) = ¶m.destruct else {
- return false;
- };
- matches!(&*desc.func.body, LExpr::Local(v) if v == id)
- }
+ Self::Normal(_) => false,
}
}
crates/jrsonnet-evaluator/src/function/prepared.rsdiffbeforeafterboth--- a/crates/jrsonnet-evaluator/src/function/prepared.rs
+++ b/crates/jrsonnet-evaluator/src/function/prepared.rs
@@ -46,6 +46,12 @@
pub fn defaults(&self) -> &[usize] {
&self.defaults
}
+ pub const fn empty() -> Self {
+ Self {
+ named: Vec::new(),
+ defaults: Vec::new(),
+ }
+ }
}
pub fn prepare_call(
crates/jrsonnet-evaluator/src/integrations/serde.rsdiffbeforeafterboth--- a/crates/jrsonnet-evaluator/src/integrations/serde.rs
+++ b/crates/jrsonnet-evaluator/src/integrations/serde.rs
@@ -12,7 +12,7 @@
};
use crate::{
- Error as JrError, ObjValue, ObjValueBuilder, Result, Val, in_description_frame, runtime_error,
+ Error as JrError, ObjValue, ObjValueBuilder, Result, Val, error, in_description_frame,
};
impl<'de> Deserialize<'de> for Val {
@@ -629,6 +629,6 @@
where
T: std::fmt::Display,
{
- runtime_error!("serde: {msg}")
+ error!("serde: {msg}")
}
}
crates/jrsonnet-evaluator/src/lib.rsdiffbeforeafterboth--- a/crates/jrsonnet-evaluator/src/lib.rs
+++ b/crates/jrsonnet-evaluator/src/lib.rs
@@ -58,6 +58,7 @@
pub use val::{Thunk, Val};
pub mod analyze;
+use self::analyze::{LExpr, analyze_root};
use crate::gc::WithCapacityExt as _;
#[allow(clippy::needless_return)]
@@ -408,12 +409,15 @@
file.evaluating = true;
// Dropping file cache guard here, as evaluation may use this map too
drop(file_cache);
- let (ctx, externals) = self.create_default_context(file_name.clone()).build();
- let report = analyze::analyze_root(&parsed, externals);
+ let (externals, thunks) = self.create_default_context(file_name).build();
+ let report = analyze_root(&parsed, externals);
if report.errored {
return Err(StaticAnalysisError(report.diagnostics_list).into());
}
- let res = evaluate::evaluate(ctx.build(), &report.lir);
+ debug_assert_eq!(report.root_shape.n_locals as usize, thunks.len());
+ debug_assert!(report.root_shape.captures.is_empty());
+ let ctx = Context::root(thunks);
+ let res = evaluate::evaluate(ctx, &report.lir);
let mut file_cache = self.file_cache();
let mut file = file_cache.entry(path);
@@ -501,33 +505,66 @@
}
}
+pub struct PreparedSnippet {
+ lir: LExpr,
+ thunks: Vec<Thunk<Val>>,
+}
+
/// Raw methods evaluate passed values but don't perform TLA execution
impl State {
- /// Parses and evaluates the given snippet
- pub fn evaluate_snippet(&self, name: impl Into<IStr>, code: impl Into<IStr>) -> Result<Val> {
- self.evaluate_snippet_with(name, code, &())
- }
- /// Parses and evaluates the given snippet with custom context modifier
- pub fn evaluate_snippet_with(
+ /// Parses and analyses the given snippet with a custom context
+ /// modifier.
+ pub fn prepare_snippet_with(
&self,
name: impl Into<IStr>,
code: impl Into<IStr>,
context_initializer: &dyn ContextInitializer,
- ) -> Result<Val> {
+ ) -> Result<PreparedSnippet> {
let code = code.into();
let source = Source::new_virtual(name.into(), code.clone());
let parsed = parse_jsonnet(&code, source.clone()).map_err(|e| ImportSyntaxError {
path: source.clone(),
error: Box::new(e),
})?;
- let (ctx, externals) = self
- .create_default_context_with(source.clone(), context_initializer)
+ let (externals, thunks) = self
+ .create_default_context_with(source, context_initializer)
.build();
- let report = analyze::analyze_root(&parsed, externals);
+ let report = analyze_root(&parsed, externals);
if report.errored {
return Err(StaticAnalysisError(report.diagnostics_list).into());
}
- evaluate::evaluate(ctx.build(), &report.lir)
+ debug_assert_eq!(report.root_shape.n_locals as usize, thunks.len());
+ debug_assert!(report.root_shape.captures.is_empty());
+ Ok(PreparedSnippet {
+ lir: report.lir,
+ thunks,
+ })
+ }
+ /// Parses and analyses the given snippet
+ pub fn prepare_snippet(
+ &self,
+ name: impl Into<IStr>,
+ code: impl Into<IStr>,
+ ) -> Result<PreparedSnippet> {
+ self.prepare_snippet_with(name, code, &())
+ }
+ pub fn evaluate_prepared_snippet(&self, prepared: &PreparedSnippet) -> Result<Val> {
+ let ctx = Context::root(prepared.thunks.clone());
+ evaluate::evaluate(ctx, &prepared.lir)
+ }
+ /// Parses and evaluates the given snippet with custom context modifier
+ pub fn evaluate_snippet_with(
+ &self,
+ name: impl Into<IStr>,
+ code: impl Into<IStr>,
+ context_initializer: &dyn ContextInitializer,
+ ) -> Result<Val> {
+ let prepared = self.prepare_snippet_with(name, code, context_initializer)?;
+ self.evaluate_prepared_snippet(&prepared)
+ }
+ /// Parses and evaluates the given snippet
+ pub fn evaluate_snippet(&self, name: impl Into<IStr>, code: impl Into<IStr>) -> Result<Val> {
+ self.evaluate_snippet_with(name, code, &())
}
}
tests/benches/cpp_test_suite.rsdiffbeforeafterboth--- a/tests/benches/cpp_test_suite.rs
+++ b/tests/benches/cpp_test_suite.rs
@@ -1,10 +1,8 @@
-use std::{collections::HashMap, fs::read_dir, hint::black_box, path::Path};
+use std::{collections::HashMap, fs, fs::read_dir, hint::black_box, path::Path};
use criterion::{Criterion, criterion_group, criterion_main};
use jrsonnet_evaluator::{
- FileImportResolver, State, apply_tla,
- manifest::{BlackBoxFormat, JsonFormat},
- stack::limit_stack_depth,
+ FileImportResolver, State, apply_tla, manifest::JsonFormat, stack::limit_stack_depth,
trace::PathResolver,
};
@@ -12,31 +10,37 @@
static GLOBAL: mimallocator::Mimalloc = mimallocator::Mimalloc;
fn bench_entry(c: &mut Criterion, path: &Path) {
- c.bench_function(
- path.file_name()
- .expect("file path")
- .to_str()
- .expect("name is utf-8"),
- |b| {
- let _stack = limit_stack_depth(200_000);
+ let name = path
+ .file_name()
+ .expect("file path")
+ .to_str()
+ .expect("name is utf-8")
+ .to_owned();
+ let code = fs::read_to_string(path).expect("read bench source");
- let mut s = State::builder();
+ c.bench_function(&name, |b| {
+ let _stack = limit_stack_depth(200_000);
- s.context_initializer(jrsonnet_stdlib::ContextInitializer::new(
- PathResolver::Absolute,
- ))
- .import_resolver(FileImportResolver::new(vec![]));
+ let mut s = State::builder();
+ s.context_initializer(jrsonnet_stdlib::ContextInitializer::new(
+ PathResolver::Absolute,
+ ))
+ .import_resolver(FileImportResolver::new(vec![]));
+ let s = s.build();
+ let _entered = s.enter();
- let s = s.build();
- let _s = s.enter();
+ // Parse + analysis happen once; each iter only measures
+ // evaluation + manifestation.
+ let prepared = s
+ .prepare_snippet(name.clone(), code.clone())
+ .expect("prepared");
- b.iter(|| {
- let imported = s.import(path).expect("evaluated");
- let res = apply_tla(&HashMap::new(), imported).expect("tla applied");
- black_box(res.manifest(JsonFormat::cli(3)).expect("manifested"));
- });
- },
- );
+ b.iter(|| {
+ let imported = s.evaluate_prepared_snippet(&prepared).expect("evaluated");
+ let res = apply_tla(&HashMap::new(), imported).expect("tla applied");
+ black_box(res.manifest(JsonFormat::cli(3)).expect("manifested"));
+ });
+ });
}
fn criterion_benchmark(c: &mut Criterion) {
for entry in read_dir("go_builtin_benchmarks").expect("dir exists") {