difftreelog
feat use visitor for async_import etc
in: master
4 files changed
crates/jrsonnet-evaluator/src/async_import.rsdiffbeforeafterboth--- a/crates/jrsonnet-evaluator/src/async_import.rs
+++ b/crates/jrsonnet-evaluator/src/async_import.rs
@@ -2,10 +2,11 @@
use std::{any::Any, cell::RefCell, future::Future};
use jrsonnet_gcmodule::Acyclic;
+use jrsonnet_ir::visit::Visitor;
use jrsonnet_ir::{
ArgsDesc, AssertExpr, AssertStmt, BindSpec, CompSpec, Destruct, Expr, ExprParam, ExprParams,
- FieldMember, FieldName, ForSpecData, IfElse, IfSpecData, ImportKind, ObjBody, Slice, SliceDesc,
- Source, SourcePath, Spanned,
+ FieldMember, FieldName, ForSpecData, IStr, IfElse, IfSpecData, ImportKind, ObjBody, Slice,
+ SliceDesc, Source, SourcePath, Spanned,
};
use rustc_hash::FxHashMap;
@@ -17,213 +18,12 @@
}
pub struct FoundImports(Vec<Import>);
-
-// Visits all nodes, trying to find import statements
-#[allow(clippy::too_many_lines)]
-pub fn find_imports(expr: &Spanned<Expr>, out: &mut FoundImports) {
- #[allow(unused_variables, clippy::needless_pass_by_ref_mut)]
- fn in_destruct(dest: &Destruct, out: &mut FoundImports) {
- match dest {
- #[cfg(feature = "exp-destruct")]
- Destruct::Array {
- start,
- rest: _,
- end,
- } => {
- for dest in start {
- in_destruct(dest, out);
- }
- for dest in end {
- in_destruct(dest, out);
- }
- }
- #[cfg(feature = "exp-destruct")]
- Destruct::Object { fields, rest: _ } => {
- for (_, dest, default) in fields {
- if let Some(dest) = dest {
- in_destruct(dest, out);
- }
- if let Some(expr) = default {
- find_imports(expr, out);
- }
- }
- }
- #[cfg(feature = "exp-destruct")]
- Destruct::Skip => {}
- Destruct::Full(_) => {}
- }
- }
- fn in_compspec(specs: &[CompSpec], out: &mut FoundImports) {
- for spec in specs {
- match spec {
- CompSpec::IfSpec(IfSpecData(expr)) => find_imports(expr, out),
- CompSpec::ForSpec(ForSpecData(destruct, expr)) => {
- in_destruct(destruct, out);
- find_imports(expr, out);
- }
- }
- }
- }
- fn in_params(params: &ExprParams, out: &mut FoundImports) {
- for ExprParam { destruct, default } in &*params.exprs {
- in_destruct(destruct, out);
- if let Some(expr) = default {
- find_imports(expr, out);
- }
- }
- }
- fn in_bind(specs: &[BindSpec], out: &mut FoundImports) {
- for spec in specs {
- match spec {
- BindSpec::Field {
- into: dest,
- value: expr,
- } => {
- in_destruct(dest, out);
- find_imports(expr, out);
- }
- BindSpec::Function {
- name: _,
- params,
- value: expr,
- } => {
- in_params(params, out);
- find_imports(expr, out);
- }
- }
- }
- }
- fn in_args(ArgsDesc { unnamed, named }: &ArgsDesc, out: &mut FoundImports) {
- for expr in unnamed {
- find_imports(expr, out);
- }
- for (_, expr) in named {
- find_imports(expr, out);
- }
- }
- fn in_obj(obj: &ObjBody, out: &mut FoundImports) {
- match obj {
- ObjBody::MemberList(obj) => {
- for FieldMember {
- name,
- params,
- value,
- ..
- } in &obj.fields
- {
- match name {
- FieldName::Fixed(_) => {}
- FieldName::Dyn(expr) => find_imports(expr, out),
- }
- if let Some(params) = params {
- in_params(params, out);
- }
- find_imports(value, out);
- }
- for _ in &*obj.locals {
- todo!()
- }
- for assert in &*obj.asserts {
- find_imports(&assert.0, out);
- if let Some(expr) = &assert.1 {
- find_imports(expr, out);
- }
- }
- }
- ObjBody::ObjComp(_) => todo!(),
- }
- }
- match &**expr {
- Expr::Import(_, v) => {
- if let Expr::Str(s) = &***v {
- out.0.push(Import {
- path: ResolvePathOwned::Str(s.to_string()),
- expression: todo!(),
- });
- }
- // Non-string import will fail in runtime
- }
-
- Expr::Literal(_) | Expr::Str(_) | Expr::Num(_) | Expr::Var(_) => {}
-
- Expr::Arr(arr) => {
- for expr in &**arr {
- find_imports(expr, out);
- }
- }
- Expr::ArrComp(expr, specs) => {
- find_imports(expr, out);
- in_compspec(specs, out);
- }
- Expr::Obj(obj) => in_obj(obj, out),
- Expr::ObjExtend(expr, obj) => {
- find_imports(expr, out);
- in_obj(obj, out);
- }
- Expr::BinaryOp(binop) => {
- find_imports(&binop.lhs, out);
- find_imports(&binop.rhs, out);
- }
- Expr::AssertExpr(assert) => {
- let AssertExpr {
- assert: AssertStmt(expr, expr2),
- rest,
- } = &**assert;
- find_imports(expr, out);
- if let Some(expr) = expr2 {
- find_imports(expr, out);
- }
- find_imports(rest, out);
- }
- Expr::LocalExpr(specs, expr) => {
- in_bind(specs, out);
- find_imports(expr, out);
- }
- Expr::Apply(expr, args, _) => {
- find_imports(expr, out);
- in_args(args, out);
- }
- Expr::Index { indexable, parts } => {
- find_imports(indexable, out);
- for part in parts {
- find_imports(&part.value, out);
- }
- }
- Expr::Function(params, expr) => {
- in_params(params, out);
- find_imports(expr, out);
- }
- Expr::IfElse(if_else) => {
- let IfElse {
- cond: IfSpecData(expr),
- cond_then,
- cond_else,
- } = &**if_else;
- find_imports(expr, out);
- find_imports(cond_then, out);
- if let Some(expr) = cond_else {
- find_imports(expr, out);
- }
- }
- Expr::Slice(slice) => {
- let Slice {
- value,
- slice: SliceDesc { start, end, step },
- } = &**slice;
- find_imports(value, out);
- if let Some(expr) = start {
- find_imports(expr, out);
- }
- if let Some(expr) = end {
- find_imports(expr, out);
- }
- if let Some(expr) = step {
- find_imports(expr, out);
- }
- }
- Expr::UnaryOp(_, expr) | Expr::ErrorStmt(expr) => {
- find_imports(expr, out);
- }
+impl Visitor for FoundImports {
+ fn visit_import(&mut self, expression: bool, value: IStr) {
+ self.0.push(Import {
+ path: ResolvePathOwned::Str(value.to_string()),
+ expression,
+ })
}
}
@@ -322,12 +122,10 @@
};
let source = Source::new(path.clone(), code.clone());
// If failed - then skip import
- file.parsed = crate::parse_jsonnet(&code, source)
- .map(Rc::new)
- .ok();
+ file.parsed = crate::parse_jsonnet(&code, source).map(Rc::new).ok();
if let Some(parsed) = &file.parsed {
let mut imports = FoundImports(vec![]);
- find_imports(parsed, &mut imports);
+ imports.visit_expr(parsed);
for import in imports.0 {
queue.push(Job::ResolveImport {
from: path.clone(),
crates/jrsonnet-ir/src/expr.rsdiffbeforeafterboth160pub struct ExprParams {160pub struct ExprParams {161 pub exprs: Rc<Vec<ExprParam>>,161 pub exprs: Rc<Vec<ExprParam>>,162 pub signature: FunctionSignature,162 pub signature: FunctionSignature,163 binds_len: usize,163 pub(crate) binds_len: usize,164}164}165impl ExprParams {165impl ExprParams {166 pub fn len(&self) -> usize {166 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);
+ }
+ }
+ }
+}