git.delta.rocks / jrsonnet / refs/commits / e9c741d736e9

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