difftreelog
feat use visitor for async_import etc
in: master
4 files changed
crates/jrsonnet-evaluator/src/async_import.rsdiffbeforeafterboth2use std::{any::Any, cell::RefCell, future::Future};2use std::{any::Any, cell::RefCell, future::Future};334use jrsonnet_gcmodule::Acyclic;4use jrsonnet_gcmodule::Acyclic;5use jrsonnet_ir::visit::Visitor;5use jrsonnet_ir::{6use jrsonnet_ir::{6 ArgsDesc, AssertExpr, AssertStmt, BindSpec, CompSpec, Destruct, Expr, ExprParam, ExprParams,7 ArgsDesc, AssertExpr, AssertStmt, BindSpec, CompSpec, Destruct, Expr, ExprParam, ExprParams,7 FieldMember, FieldName, ForSpecData, IfElse, IfSpecData, ImportKind, ObjBody, Slice, SliceDesc,8 FieldMember, FieldName, ForSpecData, IStr, IfElse, IfSpecData, ImportKind, ObjBody, Slice,8 Source, SourcePath, Spanned,9 SliceDesc, Source, SourcePath, Spanned,9};10};10use rustc_hash::FxHashMap;11use rustc_hash::FxHashMap;181919pub struct FoundImports(Vec<Import>);20pub struct FoundImports(Vec<Import>);2021// Visits all nodes, trying to find import statements22#[allow(clippy::too_many_lines)]23pub fn find_imports(expr: &Spanned<Expr>, out: &mut FoundImports) {24 #[allow(unused_variables, clippy::needless_pass_by_ref_mut)]25 fn in_destruct(dest: &Destruct, out: &mut FoundImports) {26 match dest {27 #[cfg(feature = "exp-destruct")]28 Destruct::Array {29 start,30 rest: _,31 end,32 } => {33 for dest in start {34 in_destruct(dest, out);35 }36 for dest in end {37 in_destruct(dest, out);38 }39 }40 #[cfg(feature = "exp-destruct")]41 Destruct::Object { fields, rest: _ } => {42 for (_, dest, default) in fields {43 if let Some(dest) = dest {44 in_destruct(dest, out);45 }46 if let Some(expr) = default {47 find_imports(expr, out);48 }49 }50 }51 #[cfg(feature = "exp-destruct")]52 Destruct::Skip => {}53 Destruct::Full(_) => {}54 }55 }56 fn in_compspec(specs: &[CompSpec], out: &mut FoundImports) {57 for spec in specs {21impl Visitor for FoundImports {58 match spec {59 CompSpec::IfSpec(IfSpecData(expr)) => find_imports(expr, out),60 CompSpec::ForSpec(ForSpecData(destruct, expr)) => {61 in_destruct(destruct, out);62 find_imports(expr, out);63 }64 }65 }66 }67 fn in_params(params: &ExprParams, out: &mut FoundImports) {68 for ExprParam { destruct, default } in &*params.exprs {69 in_destruct(destruct, out);70 if let Some(expr) = default {71 find_imports(expr, out);72 }73 }74 }75 fn in_bind(specs: &[BindSpec], out: &mut FoundImports) {76 for spec in specs {77 match spec {78 BindSpec::Field {79 into: dest,80 value: expr,81 } => {82 in_destruct(dest, out);83 find_imports(expr, out);84 }85 BindSpec::Function {86 name: _,87 params,88 value: expr,89 } => {90 in_params(params, out);91 find_imports(expr, out);92 }93 }94 }95 }96 fn in_args(ArgsDesc { unnamed, named }: &ArgsDesc, out: &mut FoundImports) {97 for expr in unnamed {98 find_imports(expr, out);99 }100 for (_, expr) in named {101 find_imports(expr, out);102 }103 }104 fn in_obj(obj: &ObjBody, out: &mut FoundImports) {22 fn visit_import(&mut self, expression: bool, value: IStr) {105 match obj {106 ObjBody::MemberList(obj) => {107 for FieldMember {108 name,109 params,110 value,111 ..112 } in &obj.fields113 {114 match name {115 FieldName::Fixed(_) => {}116 FieldName::Dyn(expr) => find_imports(expr, out),117 }118 if let Some(params) = params {119 in_params(params, out);120 }121 find_imports(value, out);122 }123 for _ in &*obj.locals {124 todo!()125 }126 for assert in &*obj.asserts {127 find_imports(&assert.0, out);128 if let Some(expr) = &assert.1 {129 find_imports(expr, out);130 }131 }132 }133 ObjBody::ObjComp(_) => todo!(),134 }135 }136 match &**expr {137 Expr::Import(_, v) => {138 if let Expr::Str(s) = &***v {139 out.0.push(Import {23 self.0.push(Import {140 path: ResolvePathOwned::Str(s.to_string()),24 path: ResolvePathOwned::Str(value.to_string()),141 expression: todo!(),25 expression,142 });26 })143 }144 // Non-string import will fail in runtime145 }146147 Expr::Literal(_) | Expr::Str(_) | Expr::Num(_) | Expr::Var(_) => {}148149 Expr::Arr(arr) => {150 for expr in &**arr {151 find_imports(expr, out);152 }153 }154 Expr::ArrComp(expr, specs) => {155 find_imports(expr, out);156 in_compspec(specs, out);157 }158 Expr::Obj(obj) => in_obj(obj, out),159 Expr::ObjExtend(expr, obj) => {160 find_imports(expr, out);161 in_obj(obj, out);162 }163 Expr::BinaryOp(binop) => {164 find_imports(&binop.lhs, out);165 find_imports(&binop.rhs, out);166 }167 Expr::AssertExpr(assert) => {168 let AssertExpr {169 assert: AssertStmt(expr, expr2),170 rest,171 } = &**assert;172 find_imports(expr, out);173 if let Some(expr) = expr2 {174 find_imports(expr, out);175 }176 find_imports(rest, out);177 }178 Expr::LocalExpr(specs, expr) => {179 in_bind(specs, out);180 find_imports(expr, out);181 }182 Expr::Apply(expr, args, _) => {183 find_imports(expr, out);184 in_args(args, out);185 }186 Expr::Index { indexable, parts } => {187 find_imports(indexable, out);188 for part in parts {189 find_imports(&part.value, out);190 }191 }192 Expr::Function(params, expr) => {193 in_params(params, out);194 find_imports(expr, out);195 }196 Expr::IfElse(if_else) => {197 let IfElse {198 cond: IfSpecData(expr),199 cond_then,200 cond_else,201 } = &**if_else;202 find_imports(expr, out);203 find_imports(cond_then, out);204 if let Some(expr) = cond_else {205 find_imports(expr, out);206 }207 }208 Expr::Slice(slice) => {209 let Slice {210 value,211 slice: SliceDesc { start, end, step },212 } = &**slice;213 find_imports(value, out);214 if let Some(expr) = start {215 find_imports(expr, out);216 }217 if let Some(expr) = end {218 find_imports(expr, out);219 }220 if let Some(expr) = step {221 find_imports(expr, out);222 }223 }224 Expr::UnaryOp(_, expr) | Expr::ErrorStmt(expr) => {225 find_imports(expr, out);226 }227 }27 }228}28}22929230pub trait AsyncImportResolver {30pub trait AsyncImportResolver {231 type Error;31 type Error;327 .ok();328 if let Some(parsed) = &file.parsed {126 if let Some(parsed) = &file.parsed {329 let mut imports = FoundImports(vec![]);127 let mut imports = FoundImports(vec![]);330 find_imports(parsed, &mut imports);128 imports.visit_expr(parsed);331 for import in imports.0 {129 for import in imports.0 {332 queue.push(Job::ResolveImport {130 queue.push(Job::ResolveImport {333 from: path.clone(),131 from: path.clone(),crates/jrsonnet-ir/src/expr.rsdiffbeforeafterboth--- a/crates/jrsonnet-ir/src/expr.rs
+++ b/crates/jrsonnet-ir/src/expr.rs
@@ -160,7 +160,7 @@
pub struct ExprParams {
pub exprs: Rc<Vec<ExprParam>>,
pub signature: FunctionSignature,
- binds_len: usize,
+ pub(crate) binds_len: usize,
}
impl ExprParams {
pub fn len(&self) -> usize {
crates/jrsonnet-ir/src/lib.rsdiffbeforeafterboth--- a/crates/jrsonnet-ir/src/lib.rs
+++ b/crates/jrsonnet-ir/src/lib.rs
@@ -7,6 +7,7 @@
mod location;
mod source;
pub mod unescape;
+pub mod visit;
pub use location::CodeLocation;
pub use source::{
crates/jrsonnet-ir/src/visit.rsdiffbeforeafterboth--- /dev/null
+++ b/crates/jrsonnet-ir/src/visit.rs
@@ -0,0 +1,271 @@
+use jrsonnet_interner::IStr;
+
+use crate::{
+ ArgsDesc, AssertExpr, AssertStmt, BinaryOp, BindSpec, CompSpec, Destruct, Expr, ExprParam,
+ ExprParams, FieldMember, FieldName, ForSpecData, IfElse, IfSpecData, ImportKind, IndexPart,
+ ObjBody, ObjComp, ObjMembers, Slice, SliceDesc,
+};
+
+pub trait Visitor: Sized {
+ fn visit_expr(&mut self, e: &Expr) {
+ visit_expr(self, e)
+ }
+ fn visit_import(&mut self, _as_expression: bool, _value: IStr) {}
+}
+
+#[cfg(feature = "exp-destruct")]
+pub fn visit_destruct_rest<V: Visitor>(_v: &mut V, destruct: &crate::DestructRest) {
+ match destruct {
+ crate::DestructRest::Keep(_name) => {}
+ crate::DestructRest::Drop => {}
+ }
+}
+
+pub fn visit_destruct<V: Visitor>(v: &mut V, destruct: &Destruct) {
+ match destruct {
+ Destruct::Full(_istr) => {}
+ #[cfg(feature = "exp-destruct")]
+ Destruct::Skip => {}
+ #[cfg(feature = "exp-destruct")]
+ Destruct::Array { start, rest, end } => {
+ for s in start {
+ visit_destruct(v, s);
+ }
+ if let Some(rest) = rest {
+ visit_destruct_rest(v, rest);
+ }
+ for s in end {
+ visit_destruct(v, s);
+ }
+ }
+ #[cfg(feature = "exp-destruct")]
+ Destruct::Object { fields, rest } => {
+ for (_name, into, default) in fields {
+ if let Some(into) = into {
+ visit_destruct(v, into);
+ }
+ if let Some(default) = default {
+ v.visit_expr(default);
+ }
+ if let Some(rest) = rest {
+ visit_destruct_rest(v, rest);
+ }
+ }
+ }
+ }
+}
+
+pub fn visit_if_spec<V: Visitor>(v: &mut V, cond: &IfSpecData) {
+ let IfSpecData { span: _, cond } = cond;
+ v.visit_expr(cond);
+}
+
+pub fn visit_comp_spec<V: Visitor>(v: &mut V, c: &CompSpec) {
+ match c {
+ CompSpec::IfSpec(cond) => visit_if_spec(v, cond),
+ CompSpec::ForSpec(for_spec_data) => {
+ let ForSpecData { destruct, over } = for_spec_data;
+ visit_destruct(v, destruct);
+ v.visit_expr(over);
+ }
+ }
+}
+pub fn visit_params<V: Visitor>(v: &mut V, par: &ExprParams) {
+ let ExprParams {
+ exprs,
+ signature: _,
+ binds_len: _,
+ } = par;
+ for par in &**exprs {
+ let ExprParam { destruct, default } = ∥
+ visit_destruct(v, destruct);
+ if let Some(default) = default {
+ v.visit_expr(default);
+ }
+ }
+}
+
+pub fn visit_bind_spec<V: Visitor>(v: &mut V, bind: &BindSpec) {
+ match bind {
+ BindSpec::Field { into, value } => {
+ visit_destruct(v, into);
+ v.visit_expr(value);
+ }
+ BindSpec::Function {
+ name: _,
+ params,
+ value,
+ } => {
+ visit_params(v, params);
+ v.visit_expr(value);
+ }
+ }
+}
+
+pub fn visit_field_member<V: Visitor>(v: &mut V, mem: &FieldMember) {
+ let FieldMember {
+ name,
+ plus: _,
+ params,
+ visibility: _,
+ value,
+ } = mem;
+ match &**name {
+ FieldName::Fixed(_istr) => {}
+ FieldName::Dyn(expr) => v.visit_expr(expr),
+ }
+ if let Some(params) = params {
+ visit_params(v, params);
+ }
+ v.visit_expr(value);
+}
+
+pub fn visit_obj_body<V: Visitor>(v: &mut V, obj_body: &ObjBody) {
+ match obj_body {
+ ObjBody::MemberList(obj_members) => {
+ let ObjMembers {
+ locals,
+ asserts,
+ fields,
+ } = obj_members;
+ for local in &**locals {
+ visit_bind_spec(v, local);
+ }
+ for assert in &**asserts {
+ visit_assert_stmt(v, assert);
+ }
+ for field in fields {
+ visit_field_member(v, field);
+ }
+ }
+ ObjBody::ObjComp(obj_comp) => {
+ let ObjComp {
+ locals,
+ field,
+ compspecs,
+ } = obj_comp;
+ for local in &**locals {
+ visit_bind_spec(v, local);
+ }
+ visit_field_member(v, field);
+ for compspec in compspecs {
+ visit_comp_spec(v, compspec);
+ }
+ }
+ }
+}
+
+pub fn visit_assert_stmt<V: Visitor>(v: &mut V, ass: &AssertStmt) {
+ let AssertStmt(cond, msg) = ass;
+ v.visit_expr(cond);
+ if let Some(msg) = msg {
+ v.visit_expr(msg);
+ }
+}
+pub fn visit_expr<V: Visitor>(v: &mut V, e: &Expr) {
+ match e {
+ Expr::Literal(_literal_type) => {}
+ Expr::Str(_istr) => {}
+ Expr::Num(_num) => {}
+ Expr::Var(_spanned) => {}
+ Expr::Arr(exprs) => {
+ for e in &**exprs {
+ v.visit_expr(e);
+ }
+ }
+ Expr::ArrComp(expr, comp_specs) => {
+ v.visit_expr(expr);
+ for ele in comp_specs {
+ visit_comp_spec(v, ele);
+ }
+ }
+ Expr::Obj(obj_body) => visit_obj_body(v, obj_body),
+ Expr::ObjExtend(expr, obj_body) => {
+ v.visit_expr(expr);
+ visit_obj_body(v, obj_body);
+ }
+ Expr::UnaryOp(_unary_op_type, expr) => {
+ v.visit_expr(expr);
+ }
+ Expr::BinaryOp(binary_op) => {
+ let BinaryOp { lhs, op: _, rhs } = &**binary_op;
+ v.visit_expr(lhs);
+ v.visit_expr(rhs);
+ }
+ Expr::AssertExpr(assert_expr) => {
+ let AssertExpr { assert, rest } = &**assert_expr;
+ visit_assert_stmt(v, assert);
+ v.visit_expr(rest);
+ }
+ Expr::LocalExpr(bind_specs, expr) => {
+ for local in bind_specs {
+ visit_bind_spec(v, local);
+ }
+ v.visit_expr(expr);
+ }
+ Expr::Import(kind, expr) => {
+ v.visit_expr(expr);
+
+ if let Expr::Str(expr) = &**expr {
+ v.visit_import(matches!(**kind, ImportKind::Normal), expr.clone());
+ }
+ }
+ Expr::ErrorStmt(_span, expr) => {
+ v.visit_expr(expr);
+ }
+ Expr::Apply(expr, spanned, _) => {
+ v.visit_expr(expr);
+ let ArgsDesc { unnamed, named } = &**spanned;
+ for unnamed in unnamed {
+ v.visit_expr(unnamed);
+ }
+ for (_name, named) in named {
+ v.visit_expr(named);
+ }
+ }
+ Expr::Index { indexable, parts } => {
+ v.visit_expr(indexable);
+
+ for part in parts {
+ let IndexPart {
+ span: _,
+ value,
+ #[cfg(feature = "exp-null-coaelse")]
+ null_coaelse: _,
+ } = part;
+ v.visit_expr(value);
+ }
+ }
+ Expr::Function(expr_params, expr) => {
+ visit_params(v, expr_params);
+ v.visit_expr(expr);
+ }
+ Expr::IfElse(if_else) => {
+ let IfElse {
+ cond,
+ cond_then,
+ cond_else,
+ } = &**if_else;
+ visit_if_spec(v, cond);
+ v.visit_expr(cond_then);
+ if let Some(cond_else) = cond_else {
+ v.visit_expr(cond_else);
+ }
+ }
+ Expr::Slice(slice) => {
+ let Slice { value, slice } = &**slice;
+ v.visit_expr(value);
+ let SliceDesc { start, end, step } = slice;
+
+ if let Some(start) = start {
+ v.visit_expr(start);
+ }
+ if let Some(end) = end {
+ v.visit_expr(end);
+ }
+ if let Some(step) = step {
+ v.visit_expr(step);
+ }
+ }
+ }
+}