--- 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(),
--- 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 {
--- 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::{
--- /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 } = &par;
+		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);
+			}
+		}
+	}
+}