git.delta.rocks / jrsonnet / refs/commits / 1925b3a76ba9

1use std::{cmp::Ordering, rc::Rc};23use jrsonnet_gcmodule::{Cc, Trace};4use jrsonnet_interner::IStr;5use jrsonnet_parser::{6	ArgsDesc, AssertStmt, BindSpec, CompSpec, Expr, FieldMember, FieldName, ForSpecData,7	IfSpecData, LiteralType, LocExpr, Member, ObjBody, ParamsDesc,8};9use jrsonnet_types::ValType;1011use crate::{12	destructure::evaluate_dest,13	error::Error::*,14	evaluate::operator::{evaluate_add_op, evaluate_binary_op_special, evaluate_unary_op},15	function::{CallLocation, FuncDesc, FuncVal},16	tb, throw,17	typed::Typed,18	val::{ArrValue, CachedUnbound, IndexableVal, Thunk, ThunkValue},19	Context, GcHashMap, ObjValue, ObjValueBuilder, ObjectAssertion, Pending, Result, State,20	Unbound, Val,21};22pub mod destructure;23pub mod operator;2425pub fn evaluate_method(ctx: Context, name: IStr, params: ParamsDesc, body: LocExpr) -> Val {26	Val::Func(FuncVal::Normal(Cc::new(FuncDesc {27		name,28		ctx,29		params,30		body,31	})))32}3334pub fn evaluate_field_name(ctx: Context, field_name: &FieldName) -> Result<Option<IStr>> {35	Ok(match field_name {36		FieldName::Fixed(n) => Some(n.clone()),37		FieldName::Dyn(expr) => State::push(38			CallLocation::new(&expr.1),39			|| "evaluating field name".to_string(),40			|| {41				let value = evaluate(ctx, expr)?;42				if matches!(value, Val::Null) {43					Ok(None)44				} else {45					Ok(Some(IStr::from_untyped(value)?))46				}47			},48		)?,49	})50}5152pub fn evaluate_comp(53	ctx: Context,54	specs: &[CompSpec],55	callback: &mut impl FnMut(Context) -> Result<()>,56) -> Result<()> {57	match specs.get(0) {58		None => callback(ctx)?,59		Some(CompSpec::IfSpec(IfSpecData(cond))) => {60			if bool::from_untyped(evaluate(ctx.clone(), cond)?)? {61				evaluate_comp(ctx, &specs[1..], callback)?;62			}63		}64		Some(CompSpec::ForSpec(ForSpecData(var, expr))) => match evaluate(ctx.clone(), expr)? {65			Val::Arr(list) => {66				for item in list.iter() {67					evaluate_comp(68						ctx.clone().with_var(var.clone(), item?.clone()),69						&specs[1..],70						callback,71					)?;72				}73			}74			_ => throw!(InComprehensionCanOnlyIterateOverArray),75		},76	}77	Ok(())78}7980trait CloneableUnbound<T>: Unbound<Bound = T> + Clone {}8182fn evaluate_object_locals(83	fctx: Pending<Context>,84	locals: Rc<Vec<BindSpec>>,85) -> impl CloneableUnbound<Context> {86	#[derive(Trace, Clone)]87	struct UnboundLocals {88		fctx: Pending<Context>,89		locals: Rc<Vec<BindSpec>>,90	}91	impl CloneableUnbound<Context> for UnboundLocals {}92	impl Unbound for UnboundLocals {93		type Bound = Context;9495		fn bind(&self, sup: Option<ObjValue>, this: Option<ObjValue>) -> Result<Context> {96			let fctx = Context::new_future();97			let mut new_bindings = GcHashMap::new();98			for b in self.locals.iter() {99				evaluate_dest(b, fctx.clone(), &mut new_bindings)?;100			}101102			let ctx = self.fctx.unwrap();103			let new_dollar = ctx.dollar().clone().or_else(|| this.clone());104105			let ctx = ctx106				.extend(new_bindings, new_dollar, sup, this)107				.into_future(fctx);108109			Ok(ctx)110		}111	}112113	UnboundLocals { fctx, locals }114}115116#[allow(clippy::too_many_lines)]117pub fn evaluate_member_list_object(ctx: Context, members: &[Member]) -> Result<ObjValue> {118	let mut builder = ObjValueBuilder::new();119	let locals = Rc::new(120		members121			.iter()122			.filter_map(|m| match m {123				Member::BindStmt(bind) => Some(bind.clone()),124				_ => None,125			})126			.collect::<Vec<_>>(),127	);128129	let fctx = Context::new_future();130131	// We have single context for all fields, so we can cache binds132	let uctx = CachedUnbound::new(evaluate_object_locals(fctx.clone(), locals));133134	for member in members.iter() {135		match member {136			Member::Field(FieldMember {137				name,138				plus,139				params: None,140				visibility,141				value,142			}) => {143				#[derive(Trace)]144				struct UnboundValue<B: Trace> {145					uctx: B,146					value: LocExpr,147					name: IStr,148				}149				impl<B: Unbound<Bound = Context>> Unbound for UnboundValue<B> {150					type Bound = Thunk<Val>;151					fn bind(152						&self,153						sup: Option<ObjValue>,154						this: Option<ObjValue>,155					) -> Result<Thunk<Val>> {156						Ok(Thunk::evaluated(evaluate_named(157							self.uctx.bind(sup, this)?,158							&self.value,159							self.name.clone(),160						)?))161					}162				}163164				let name = evaluate_field_name(ctx.clone(), name)?;165				let name = if let Some(name) = name {166					name167				} else {168					continue;169				};170171				builder172					.member(name.clone())173					.with_add(*plus)174					.with_visibility(*visibility)175					.with_location(value.1.clone())176					.bindable(tb!(UnboundValue {177						uctx: uctx.clone(),178						value: value.clone(),179						name: name.clone()180					}))?;181			}182			Member::Field(FieldMember {183				name,184				params: Some(params),185				value,186				..187			}) => {188				#[derive(Trace)]189				struct UnboundMethod<B: Trace> {190					uctx: B,191					value: LocExpr,192					params: ParamsDesc,193					name: IStr,194				}195				impl<B: Unbound<Bound = Context>> Unbound for UnboundMethod<B> {196					type Bound = Thunk<Val>;197					fn bind(198						&self,199						sup: Option<ObjValue>,200						this: Option<ObjValue>,201					) -> Result<Thunk<Val>> {202						Ok(Thunk::evaluated(evaluate_method(203							self.uctx.bind(sup, this)?,204							self.name.clone(),205							self.params.clone(),206							self.value.clone(),207						)))208					}209				}210211				let name = if let Some(name) = evaluate_field_name(ctx.clone(), name)? {212					name213				} else {214					continue;215				};216217				builder218					.member(name.clone())219					.hide()220					.with_location(value.1.clone())221					.bindable(tb!(UnboundMethod {222						uctx: uctx.clone(),223						value: value.clone(),224						params: params.clone(),225						name: name.clone()226					}))?;227			}228			Member::BindStmt(_) => {}229			Member::AssertStmt(stmt) => {230				#[derive(Trace)]231				struct ObjectAssert<B: Trace> {232					uctx: B,233					assert: AssertStmt,234				}235				impl<B: Unbound<Bound = Context>> ObjectAssertion for ObjectAssert<B> {236					fn run(&self, sup: Option<ObjValue>, this: Option<ObjValue>) -> Result<()> {237						let ctx = self.uctx.bind(sup, this)?;238						evaluate_assert(ctx, &self.assert)239					}240				}241				builder.assert(tb!(ObjectAssert {242					uctx: uctx.clone(),243					assert: stmt.clone(),244				}));245			}246		}247	}248	let this = builder.build();249	fctx.fill(ctx.extend(GcHashMap::new(), None, None, Some(this.clone())));250	Ok(this)251}252253pub fn evaluate_object(ctx: Context, object: &ObjBody) -> Result<ObjValue> {254	Ok(match object {255		ObjBody::MemberList(members) => evaluate_member_list_object(ctx, members)?,256		ObjBody::ObjComp(obj) => {257			let mut builder = ObjValueBuilder::new();258			let locals = Rc::new(259				obj.pre_locals260					.iter()261					.chain(obj.post_locals.iter())262					.cloned()263					.collect::<Vec<_>>(),264			);265			let mut ctxs = vec![];266			evaluate_comp(ctx, &obj.compspecs, &mut |ctx| {267				let key = evaluate(ctx.clone(), &obj.key)?;268				let fctx = Context::new_future();269				ctxs.push((ctx, fctx.clone()));270				let uctx = evaluate_object_locals(fctx, locals.clone());271272				match key {273					Val::Null => {}274					Val::Str(n) => {275						#[derive(Trace)]276						struct UnboundValue<B: Trace> {277							uctx: B,278							value: LocExpr,279						}280						impl<B: Unbound<Bound = Context>> Unbound for UnboundValue<B> {281							type Bound = Thunk<Val>;282							fn bind(283								&self,284								sup: Option<ObjValue>,285								this: Option<ObjValue>,286							) -> Result<Thunk<Val>> {287								Ok(Thunk::evaluated(evaluate(288									self.uctx.bind(sup, this.clone())?.extend(289										GcHashMap::new(),290										None,291										None,292										this,293									),294									&self.value,295								)?))296							}297						}298						builder299							.member(n)300							.with_location(obj.value.1.clone())301							.with_add(obj.plus)302							.bindable(tb!(UnboundValue {303								uctx,304								value: obj.value.clone(),305							}))?;306					}307					v => throw!(FieldMustBeStringGot(v.value_type())),308				}309310				Ok(())311			})?;312313			let this = builder.build();314			for (ctx, fctx) in ctxs {315				let _ctx = ctx316					.extend(GcHashMap::new(), None, None, Some(this.clone()))317					.into_future(fctx);318			}319			this320		}321	})322}323324pub fn evaluate_apply(325	ctx: Context,326	value: &LocExpr,327	args: &ArgsDesc,328	loc: CallLocation<'_>,329	tailstrict: bool,330) -> Result<Val> {331	let value = evaluate(ctx.clone(), value)?;332	Ok(match value {333		Val::Func(f) => {334			let body = || f.evaluate(ctx, loc, args, tailstrict);335			if tailstrict {336				body()?337			} else {338				State::push(loc, || format!("function <{}> call", f.name()), body)?339			}340		}341		v => throw!(OnlyFunctionsCanBeCalledGot(v.value_type())),342	})343}344345pub fn evaluate_assert(ctx: Context, assertion: &AssertStmt) -> Result<()> {346	let value = &assertion.0;347	let msg = &assertion.1;348	let assertion_result = State::push(349		CallLocation::new(&value.1),350		|| "assertion condition".to_owned(),351		|| bool::from_untyped(evaluate(ctx.clone(), value)?),352	)?;353	if !assertion_result {354		State::push(355			CallLocation::new(&value.1),356			|| "assertion failure".to_owned(),357			|| {358				if let Some(msg) = msg {359					throw!(AssertionFailed(evaluate(ctx, msg)?.to_string()?));360				}361				throw!(AssertionFailed(Val::Null.to_string()?));362			},363		)?;364	}365	Ok(())366}367368pub fn evaluate_named(ctx: Context, expr: &LocExpr, name: IStr) -> Result<Val> {369	use Expr::*;370	let LocExpr(raw_expr, _loc) = expr;371	Ok(match &**raw_expr {372		Function(params, body) => evaluate_method(ctx, name, params.clone(), body.clone()),373		_ => evaluate(ctx, expr)?,374	})375}376377#[allow(clippy::too_many_lines)]378pub fn evaluate(ctx: Context, expr: &LocExpr) -> Result<Val> {379	use Expr::*;380	let LocExpr(expr, loc) = expr;381	// let bp = with_state(|s| s.0.stop_at.borrow().clone());382	Ok(match &**expr {383		Literal(LiteralType::This) => {384			Val::Obj(ctx.this().clone().ok_or(CantUseSelfOutsideOfObject)?)385		}386		Literal(LiteralType::Super) => Val::Obj(387			ctx.super_obj().clone().ok_or(NoSuperFound)?.with_this(388				ctx.this()389					.clone()390					.expect("if super exists - then this should to"),391			),392		),393		Literal(LiteralType::Dollar) => {394			Val::Obj(ctx.dollar().clone().ok_or(NoTopLevelObjectFound)?)395		}396		Literal(LiteralType::True) => Val::Bool(true),397		Literal(LiteralType::False) => Val::Bool(false),398		Literal(LiteralType::Null) => Val::Null,399		Parened(e) => evaluate(ctx, e)?,400		Str(v) => Val::Str(v.clone()),401		Num(v) => Val::new_checked_num(*v)?,402		BinaryOp(v1, o, v2) => evaluate_binary_op_special(ctx, v1, *o, v2)?,403		UnaryOp(o, v) => evaluate_unary_op(*o, &evaluate(ctx, v)?)?,404		Var(name) => State::push(405			CallLocation::new(loc),406			|| format!("variable <{name}> access"),407			|| ctx.binding(name.clone())?.evaluate(),408		)?,409		Index(value, index) => match (evaluate(ctx.clone(), value)?, evaluate(ctx, index)?) {410			(Val::Obj(v), Val::Str(key)) => State::push(411				CallLocation::new(loc),412				|| format!("field <{key}> access"),413				|| match v.get(key.clone()) {414					Ok(Some(v)) => Ok(v),415					#[cfg(not(feature = "friendly-errors"))]416					Ok(None) => throw!(NoSuchField(key.clone(), vec![])),417					#[cfg(feature = "friendly-errors")]418					Ok(None) => {419						let mut heap = Vec::new();420						for field in v.fields_ex(421							true,422							#[cfg(feature = "exp-preserve-order")]423							false,424						) {425							let conf = strsim::jaro_winkler(&field as &str, &key as &str);426							if conf < 0.8 {427								continue;428							}429							heap.push((conf, field));430						}431						heap.sort_by(|a, b| b.0.partial_cmp(&a.0).unwrap_or(Ordering::Equal));432433						throw!(NoSuchField(434							key.clone(),435							heap.into_iter().map(|(_, v)| v).collect()436						))437					}438					Err(e) => Err(e),439				},440			)?,441			(Val::Obj(_), n) => throw!(ValueIndexMustBeTypeGot(442				ValType::Obj,443				ValType::Str,444				n.value_type(),445			)),446447			(Val::Arr(v), Val::Num(n)) => {448				if n.fract() > f64::EPSILON {449					throw!(FractionalIndex)450				}451				v.get(n as usize)?452					.ok_or_else(|| ArrayBoundsError(n as usize, v.len()))?453			}454			(Val::Arr(_), Val::Str(n)) => throw!(AttemptedIndexAnArrayWithString(n)),455			(Val::Arr(_), n) => throw!(ValueIndexMustBeTypeGot(456				ValType::Arr,457				ValType::Num,458				n.value_type(),459			)),460461			(Val::Str(s), Val::Num(n)) => Val::Str({462				let v: IStr = s463					.chars()464					.skip(n as usize)465					.take(1)466					.collect::<String>()467					.into();468				if v.is_empty() {469					let size = s.chars().count();470					throw!(StringBoundsError(n as usize, size))471				}472				v473			}),474			(Val::Str(_), n) => throw!(ValueIndexMustBeTypeGot(475				ValType::Str,476				ValType::Num,477				n.value_type(),478			)),479480			(v, _) => throw!(CantIndexInto(v.value_type())),481		},482		LocalExpr(bindings, returned) => {483			let mut new_bindings: GcHashMap<IStr, Thunk<Val>> =484				GcHashMap::with_capacity(bindings.len());485			let fctx = Context::new_future();486			for b in bindings {487				evaluate_dest(b, fctx.clone(), &mut new_bindings)?;488			}489			let ctx = ctx.extend(new_bindings, None, None, None).into_future(fctx);490			evaluate(ctx, &returned.clone())?491		}492		Arr(items) => {493			let mut out = Vec::with_capacity(items.len());494			for item in items {495				// TODO: Implement ArrValue::Lazy with same context for every element?496				#[derive(Trace)]497				struct ArrayElement {498					ctx: Context,499					item: LocExpr,500				}501				impl ThunkValue for ArrayElement {502					type Output = Val;503					fn get(self: Box<Self>) -> Result<Val> {504						evaluate(self.ctx, &self.item)505					}506				}507				out.push(Thunk::new(tb!(ArrayElement {508					ctx: ctx.clone(),509					item: item.clone(),510				})));511			}512			Val::Arr(out.into())513		}514		ArrComp(expr, comp_specs) => {515			let mut out = Vec::new();516			evaluate_comp(ctx, comp_specs, &mut |ctx| {517				out.push(evaluate(ctx, expr)?);518				Ok(())519			})?;520			Val::Arr(ArrValue::Eager(Cc::new(out)))521		}522		Obj(body) => Val::Obj(evaluate_object(ctx, body)?),523		ObjExtend(a, b) => evaluate_add_op(524			&evaluate(ctx.clone(), a)?,525			&Val::Obj(evaluate_object(ctx, b)?),526		)?,527		Apply(value, args, tailstrict) => {528			evaluate_apply(ctx, value, args, CallLocation::new(loc), *tailstrict)?529		}530		Function(params, body) => {531			evaluate_method(ctx, "anonymous".into(), params.clone(), body.clone())532		}533		AssertExpr(assert, returned) => {534			evaluate_assert(ctx.clone(), assert)?;535			evaluate(ctx, returned)?536		}537		ErrorStmt(e) => State::push(538			CallLocation::new(loc),539			|| "error statement".to_owned(),540			|| throw!(RuntimeError(evaluate(ctx, e)?.to_string()?,)),541		)?,542		IfElse {543			cond,544			cond_then,545			cond_else,546		} => {547			if State::push(548				CallLocation::new(loc),549				|| "if condition".to_owned(),550				|| bool::from_untyped(evaluate(ctx.clone(), &cond.0)?),551			)? {552				evaluate(ctx, cond_then)?553			} else {554				match cond_else {555					Some(v) => evaluate(ctx, v)?,556					None => Val::Null,557				}558			}559		}560		Slice(value, desc) => {561			fn parse_idx<T: Typed>(562				loc: CallLocation<'_>,563				ctx: &Context,564				expr: &Option<LocExpr>,565				desc: &'static str,566			) -> Result<Option<T>> {567				if let Some(value) = expr {568					Ok(Some(State::push(569						loc,570						|| format!("slice {desc}"),571						|| T::from_untyped(evaluate(ctx.clone(), value)?),572					)?))573				} else {574					Ok(None)575				}576			}577578			let indexable = evaluate(ctx.clone(), value)?;579			let loc = CallLocation::new(loc);580581			let start = parse_idx(loc, &ctx, &desc.start, "start")?;582			let end = parse_idx(loc, &ctx, &desc.end, "end")?;583			let step = parse_idx(loc, &ctx, &desc.step, "step")?;584585			IndexableVal::into_untyped(indexable.into_indexable()?.slice(start, end, step)?)?586		}587		i @ (Import(path) | ImportStr(path) | ImportBin(path)) => {588			let tmp = loc.clone().0;589			let s = ctx.state();590			let resolved_path = s.resolve_from(tmp.source_path(), path as &str)?;591			match i {592				Import(_) => State::push(593					CallLocation::new(loc),594					|| format!("import {:?}", path.clone()),595					|| s.import_resolved(resolved_path),596				)?,597				ImportStr(_) => Val::Str(s.import_resolved_str(resolved_path)?),598				ImportBin(_) => Val::Arr(ArrValue::Bytes(s.import_resolved_bin(resolved_path)?)),599				_ => unreachable!(),600			}601		}602	})603}