Support a visitor trait similar to swc

[bvanjoi]

Currently, the visitor trait provides a flat way to traverse the AST, but sometimes an expanded tree is easier for handling context. The API for this format is like this:

trait Visitor {
   fn visit_any_js_root(&mut self, node: AnyJsRoot) {
            match root {
                    AnyJsRoot::JsExpressionSnipped(node) => self.visit_js_expression_snipped(node),
                    AnyJsRoot::JsModule(node) => self.visit_js_module(node),
                    AnyJsRoot::JsScript(node) => self.visit_js_script(node),
             }
   }

   fn visit_xxxxx(&mut self) {}
   // .......
}

[Conaclos]

How is this different from our current Visitor? I don't understand what you are proposing.

[bvanjoi]

Now I use PreOrder to traverse all AST nodes. For example:

fn visit(root: AnyJsRoot) {
    let mut ctx = Context::new();
    for node in root.syntax().preorder() {
        match node {
            WalkEvent::Enter(node) => {
                if is_satisfy_a(&node, &ctx) {
                   // do something for a
                } else if is_satisfy_b(&node, &ctx) {
                   // do something b
                } else {
                   // other things
                }
            }
            WalkEvent::Leave(node) => {
                if is_satisfy_a(&node, &ctx) {
                   // revert something for a
                } else if is_satisfy_b(&node, &ctx) {
                   // revert something for  b
                } else {
                   // other things
                }
            }
        }
    }
}

As you can see, I will have to list many branches if there's too much context. However, if we implement the Visitor trait as I propose, we can avoid these branches.

How is this different from our current Visitor

Or perhaps a similar feature has already been implemented, and I just haven't noticed? 🤔

[bvanjoi]

if we implement the Visitor trait as I propose, we can avoid these branches.

The example is:

impl Visitor for Context {
    fn visit_node_a(&mut self, node_a: NodeA) {
        if !is_satisfy_a(node_a, self) {
            return 
        } else {
            self.visit_node_b(&mut self)
        }
    }

    fn visit_node_b(&mut self, node_b: NodeB) {
        if !is_satisfy_b(node_b, self) {
            return 
        } else {
            // do somethings
        } 
    }
}

[Conaclos]

Not sure if it fit your use case, however you can use a custom visitor for implementing a lint rule. See the dedicated section in our Analyzer contributing guide.