Overriding or dynamic dispatch equivalent in rust

I've been learning rust for a while and loving it. I've hit a wall though trying to do something which ought to be simple and elegant so I'm sure I'm missing the obvious.

So I'm parsing JavaScript using the excellent RESSA crate and end up with an AST which is a graph of structs defined by the crate.
Now I need to traverse this many times and 'visit' certain nodes with my logic.

I've written a traverser that does that but when it hits a certain nodes it needs to call a callback.

In my niavity, I thought I'd define a struct with an attribute for every type with an Option<Fn(<type>)> value.
In my traverser, I check for the Some value and call it.
This works fine but it's ugly because I have to populate this enormous struct with dozens of attributes most of which are None because I'm not interested in those types.

Then I thought traits, I'd define a trait Visit which defines the function with a default implementation that does nothing. Then I can just redefine the trait implementation with my desired implementation but this is no good because all the types must have an implementation and then the implementation cannot be redefined.

Is there as nice way I can just provide a specific implementation for a few types and leave the rest as default or check for the existence of a function before calling it?

I must be missing an idiomatic way to do this.

You can look at something like syn::Visit, which is a visitor in a popular Rust AST library, for inspiration.

The Visit trait is implemented by the visitor only, and has one method for each node type, with the default implementation only visiting the children:

// this snippet has been slightly altered from the source

pub trait Visit<'ast> {
    fn visit_expr(&mut self, i: &'ast Expr) {
        visit_expr(self, i);
    }
    
    fn visit_expr_array(&mut self, i: &'ast ExprArray) {
        visit_expr_array(self, i);
    }
    
    fn visit_expr_assign(&mut self, i: &'ast ExprAssign) {
        visit_expr_assign(self, i);
    }

    // ...
}

pub fn visit_expr<'ast, V>(v: &mut V, node: &'ast Expr)
where
    V: Visit<'ast> + ?Sized,
{
    match node {
        Expr::Array(_binding_0) => v.visit_expr_array(_binding_0),
        Expr::Assign(_binding_0) => v.visit_expr_assign(_binding_0),
        // ...
   }
}

pub fn visit_expr_array<'ast, V>(v: &mut V, node: &'ast ExprArray)
where
    V: Visit<'ast> + ?Sized,
{
    for el in &node.elems {
        v.visit_expr(el);
    }
}

// ...

With this pattern, you can create a visitor where you only implement the methods you need, and whatever you don't implement will just get the default behavior.

Additionally, because the default methods call separate functions that do the default behavior, you can call those within your custom visitor methods if you need to invoke the default behavior of visiting the children. (Rust doesn't let you invoke default implementations of an overriden trait method directly.) So for example, a visitor to print all array expressions in a Rust program using syn::Visit could look like:

struct MyVisitor;

impl Visit<'ast> for MyVisitor {
    fn visit_expr_array(&mut self, i: &'ast ExprArray) {
        println("{:?}", i);
        
        // call default visitor method to visit this node's children as well
        visit_expr_array(i);
    }
}

fn main() {
  let root = get_ast_root_node();
  MyVisitor.visit_expr(&root);
}