1use std::{collections::HashMap, hash::BuildHasher};23use jrsonnet_interner::IStr;4use jrsonnet_parser::{BindSpec, Destruct};56use crate::{7 bail,8 error::{ErrorKind::*, Result},9 evaluate_method, evaluate_named_param, Context, Pending, Thunk, Val,10};1112#[cfg(feature = "exp-preserve-order")]13use crate::evaluate;1415#[allow(clippy::too_many_lines)]16#[allow(unused_variables)]17pub fn destruct<H: BuildHasher>(18 d: &Destruct,19 parent: Thunk<Val>,20 fctx: Pending<Context>,21 new_bindings: &mut HashMap<IStr, Thunk<Val>, H>,22) -> Result<()> {23 match d {24 Destruct::Full(v) => {25 let old = new_bindings.insert(v.clone(), parent);26 if old.is_some() {27 bail!(DuplicateLocalVar(v.clone()))28 }29 }30 #[cfg(feature = "exp-destruct")]31 Destruct::Skip => {}32 #[cfg(feature = "exp-destruct")]33 Destruct::Array { start, rest, end } => {34 use jrsonnet_parser::DestructRest;3536 let min_len = start.len() + end.len();37 let has_rest = rest.is_some();38 let full = Thunk!(move || {39 let v = parent.evaluate()?;40 let Val::Arr(arr) = v else {41 bail!("expected array");42 };43 if !has_rest {44 if arr.len() != min_len {45 bail!("expected {} elements, got {}", min_len, arr.len())46 }47 } else if arr.len() < min_len {48 bail!(49 "expected at least {} elements, but array was only {}",50 min_len,51 arr.len()52 )53 }54 Ok(arr)55 });5657 {58 for (i, d) in start.iter().enumerate() {59 let full = full.clone();60 destruct(61 d,62 Thunk!(move || Ok(full.evaluate()?.get(i)?.expect("length is checked"))),63 fctx.clone(),64 new_bindings,65 )?;66 }67 }6869 match rest {70 Some(DestructRest::Keep(v)) => {71 let start = start.len();72 let end = end.len();73 let full = full.clone();74 destruct(75 &Destruct::Full(v.clone()),76 Thunk!(move || {77 let full = full.evaluate()?;78 let to = full.len() - end;79 Ok(Val::Arr(full.slice(80 Some(start as i32),81 Some(to as i32),82 None,83 )))84 }),85 fctx.clone(),86 new_bindings,87 )?;88 }89 Some(DestructRest::Drop) | None => {}90 }9192 {93 for (i, d) in end.iter().enumerate() {94 let full = full.clone();95 let end = end.len();96 destruct(97 d,98 Thunk!(move || {99 let full = full.evaluate()?;100 Ok(full.get(full.len() - end + i)?.expect("length is checked"))101 }),102 fctx.clone(),103 new_bindings,104 )?;105 }106 }107 }108 #[cfg(feature = "exp-destruct")]109 Destruct::Object { fields, rest } => {110 let field_names: Vec<_> = fields111 .iter()112 .map(|f| (f.0.clone(), f.2.is_some()))113 .collect();114 let has_rest = rest.is_some();115 let full = Thunk!(move || {116 let v = parent.evaluate()?;117 let Val::Obj(obj) = v else {118 bail!("expected object");119 };120 for (field, has_default) in &field_names {121 if !has_default && !obj.has_field_ex(field.clone(), true) {122 bail!("missing field: {field}");123 }124 }125 if !has_rest {126 let len = obj.len();127 if len > field_names.len() {128 bail!("too many fields, and rest not found");129 }130 }131 Ok(obj)132 });133134 for (field, d, default) in fields {135 let default = default.clone().map(|e| (fctx.clone(), e));136 let value = {137 let field = field.clone();138 let full = full.clone();139 Thunk!(move || {140 let full = full.evaluate()?;141 if let Some(field) = full.get(field)? {142 Ok(field)143 } else {144 let (fctx, expr) = default.as_ref().expect("shape is checked");145 Ok(evaluate(fctx.clone().unwrap(), expr)?)146 }147 })148 };149150 if let Some(d) = d {151 destruct(d, value, fctx.clone(), new_bindings)?;152 } else {153 destruct(154 &Destruct::Full(field.clone()),155 value,156 fctx.clone(),157 new_bindings,158 )?;159 }160 }161 }162 }163 Ok(())164}165166pub fn evaluate_dest<H: BuildHasher>(167 d: &BindSpec,168 fctx: Pending<Context>,169 new_bindings: &mut HashMap<IStr, Thunk<Val>, H>,170) -> Result<()> {171 match d {172 BindSpec::Field { into, value } => {173 let name = into.name();174 let value = value.clone();175 let data = {176 let fctx = fctx.clone();177 Thunk!(move || evaluate_named_param(fctx.unwrap(), &value, name))178 };179 destruct(into, data, fctx, new_bindings)?;180 }181 BindSpec::Function {182 name,183 params,184 value,185 } => {186 let params = params.clone();187 let name = name.clone();188 let value = value.clone();189 let old = new_bindings.insert(name.clone(), {190 let name = name.clone();191 Thunk!(move || Ok(evaluate_method(fctx.unwrap(), name, params, value)))192 });193 if old.is_some() {194 bail!(DuplicateLocalVar(name))195 }196 }197 }198 Ok(())199}