1use jrsonnet_interner::IStr;23use crate::{4 ArgsDesc, AssertExpr, AssertStmt, BinaryOp, BindSpec, CompSpec, Destruct, Expr, ExprParam,5 ExprParams, FieldMember, FieldName, ForSpecData, IfElse, IfSpecData, ImportKind, IndexPart,6 ObjBody, ObjComp, ObjMembers, Slice, SliceDesc,7};89pub trait Visitor: Sized {10 fn visit_expr(&mut self, e: &Expr) {11 visit_expr(self, e)12 }13 fn visit_import(&mut self, _as_expression: bool, _value: IStr) {}14}1516#[cfg(feature = "exp-destruct")]17pub fn visit_destruct_rest<V: Visitor>(_v: &mut V, destruct: &crate::DestructRest) {18 match destruct {19 crate::DestructRest::Keep(_name) => {}20 crate::DestructRest::Drop => {}21 }22}2324pub fn visit_destruct<V: Visitor>(v: &mut V, destruct: &Destruct) {25 match destruct {26 Destruct::Full(_istr) => {}27 #[cfg(feature = "exp-destruct")]28 Destruct::Skip => {}29 #[cfg(feature = "exp-destruct")]30 Destruct::Array { start, rest, end } => {31 for s in start {32 visit_destruct(v, s);33 }34 if let Some(rest) = rest {35 visit_destruct_rest(v, rest);36 }37 for s in end {38 visit_destruct(v, s);39 }40 }41 #[cfg(feature = "exp-destruct")]42 Destruct::Object { fields, rest } => {43 for (_name, into, default) in fields {44 if let Some(into) = into {45 visit_destruct(v, into);46 }47 if let Some(default) = default {48 v.visit_expr(default);49 }50 if let Some(rest) = rest {51 visit_destruct_rest(v, rest);52 }53 }54 }55 }56}5758pub fn visit_if_spec<V: Visitor>(v: &mut V, cond: &IfSpecData) {59 let IfSpecData { span: _, cond } = cond;60 v.visit_expr(cond);61}6263pub fn visit_comp_spec<V: Visitor>(v: &mut V, c: &CompSpec) {64 match c {65 CompSpec::IfSpec(cond) => visit_if_spec(v, cond),66 CompSpec::ForSpec(for_spec_data) => {67 let ForSpecData { destruct, over } = for_spec_data;68 visit_destruct(v, destruct);69 v.visit_expr(over);70 }71 }72}73pub fn visit_params<V: Visitor>(v: &mut V, par: &ExprParams) {74 let ExprParams {75 exprs,76 signature: _,77 binds_len: _,78 } = par;79 for par in &**exprs {80 let ExprParam { destruct, default } = ∥81 visit_destruct(v, destruct);82 if let Some(default) = default {83 v.visit_expr(default);84 }85 }86}8788pub fn visit_bind_spec<V: Visitor>(v: &mut V, bind: &BindSpec) {89 match bind {90 BindSpec::Field { into, value } => {91 visit_destruct(v, into);92 v.visit_expr(value);93 }94 BindSpec::Function {95 name: _,96 params,97 value,98 } => {99 visit_params(v, params);100 v.visit_expr(value);101 }102 }103}104105pub fn visit_field_member<V: Visitor>(v: &mut V, mem: &FieldMember) {106 let FieldMember {107 name,108 plus: _,109 params,110 visibility: _,111 value,112 } = mem;113 match &**name {114 FieldName::Fixed(_istr) => {}115 FieldName::Dyn(expr) => v.visit_expr(expr),116 }117 if let Some(params) = params {118 visit_params(v, params);119 }120 v.visit_expr(value);121}122123pub fn visit_obj_body<V: Visitor>(v: &mut V, obj_body: &ObjBody) {124 match obj_body {125 ObjBody::MemberList(obj_members) => {126 let ObjMembers {127 locals,128 asserts,129 fields,130 } = obj_members;131 for local in &**locals {132 visit_bind_spec(v, local);133 }134 for assert in &**asserts {135 visit_assert_stmt(v, assert);136 }137 for field in fields {138 visit_field_member(v, field);139 }140 }141 ObjBody::ObjComp(obj_comp) => {142 let ObjComp {143 locals,144 field,145 compspecs,146 } = obj_comp;147 for local in &**locals {148 visit_bind_spec(v, local);149 }150 visit_field_member(v, field);151 for compspec in compspecs {152 visit_comp_spec(v, compspec);153 }154 }155 }156}157158pub fn visit_assert_stmt<V: Visitor>(v: &mut V, ass: &AssertStmt) {159 let AssertStmt(cond, msg) = ass;160 v.visit_expr(cond);161 if let Some(msg) = msg {162 v.visit_expr(msg);163 }164}165pub fn visit_expr<V: Visitor>(v: &mut V, e: &Expr) {166 match e {167 Expr::Literal(_literal_type) => {}168 Expr::Str(_istr) => {}169 Expr::Num(_num) => {}170 Expr::Var(_spanned) => {}171 Expr::Arr(exprs) => {172 for e in &**exprs {173 v.visit_expr(e);174 }175 }176 Expr::ArrComp(expr, comp_specs) => {177 v.visit_expr(expr);178 for ele in comp_specs {179 visit_comp_spec(v, ele);180 }181 }182 Expr::Obj(obj_body) => visit_obj_body(v, obj_body),183 Expr::ObjExtend(expr, obj_body) => {184 v.visit_expr(expr);185 visit_obj_body(v, obj_body);186 }187 Expr::UnaryOp(_unary_op_type, expr) => {188 v.visit_expr(expr);189 }190 Expr::BinaryOp(binary_op) => {191 let BinaryOp { lhs, op: _, rhs } = &**binary_op;192 v.visit_expr(lhs);193 v.visit_expr(rhs);194 }195 Expr::AssertExpr(assert_expr) => {196 let AssertExpr { assert, rest } = &**assert_expr;197 visit_assert_stmt(v, assert);198 v.visit_expr(rest);199 }200 Expr::LocalExpr(bind_specs, expr) => {201 for local in bind_specs {202 visit_bind_spec(v, local);203 }204 v.visit_expr(expr);205 }206 Expr::Import(kind, expr) => {207 v.visit_expr(expr);208209 if let Expr::Str(expr) = &**expr {210 v.visit_import(matches!(**kind, ImportKind::Normal), expr.clone());211 }212 }213 Expr::ErrorStmt(_span, expr) => {214 v.visit_expr(expr);215 }216 Expr::Apply(expr, spanned, _) => {217 v.visit_expr(expr);218 let ArgsDesc { unnamed, named } = &**spanned;219 for unnamed in unnamed {220 v.visit_expr(unnamed);221 }222 for (_name, named) in named {223 v.visit_expr(named);224 }225 }226 Expr::Index { indexable, parts } => {227 v.visit_expr(indexable);228229 for part in parts {230 let IndexPart {231 span: _,232 value,233 #[cfg(feature = "exp-null-coaelse")]234 null_coaelse: _,235 } = part;236 v.visit_expr(value);237 }238 }239 Expr::Function(expr_params, expr) => {240 visit_params(v, expr_params);241 v.visit_expr(expr);242 }243 Expr::IfElse(if_else) => {244 let IfElse {245 cond,246 cond_then,247 cond_else,248 } = &**if_else;249 visit_if_spec(v, cond);250 v.visit_expr(cond_then);251 if let Some(cond_else) = cond_else {252 v.visit_expr(cond_else);253 }254 }255 Expr::Slice(slice) => {256 let Slice { value, slice } = &**slice;257 v.visit_expr(value);258 let SliceDesc { start, end, step } = slice;259260 if let Some(start) = start {261 v.visit_expr(start);262 }263 if let Some(end) = end {264 v.visit_expr(end);265 }266 if let Some(step) = step {267 v.visit_expr(step);268 }269 }270 }271}