Visitor for stable rust

[kdy1]

I've implemented a Visitor for stable rustc.
The implementation is naive, but it works.

Generated code looks like

pub trait Visit {
   #[allow(unused_variables)]
    fn visit_array_lit(&self, n: &ArrayLit, _parent: &dyn Node) {
        match n {
            ArrayLit { span, elems } => {
                self.visit_span(&*span, n as _);
                self.visit_opt_vec_expr_or_spreads(&*elems, n as _);
            }
        }
    }
    // .. LOTS of generated methods
    #[allow(unused_variables)]
    fn visit_decl(&self, n: &Decl, _parent: &dyn Node) {
        match n {
            Decl::Class { 0: _0 } => {
                self.visit_class_decl(&*_0, n as _);
            }
            Decl::Fn { 0: _0 } => {
                self.visit_fn_decl(&*_0, n as _);
            }
            Decl::Var { 0: _0 } => {
                self.visit_var_decl(&*_0, n as _);
            }
            Decl::TsInterface { 0: _0 } => {
                self.visit_ts_interface_decl(&*_0, n as _);
            }
            Decl::TsTypeAlias { 0: _0 } => {
                self.visit_ts_type_alias_decl(&*_0, n as _);
            }
            Decl::TsEnum { 0: _0 } => {
                self.visit_ts_enum_decl(&*_0, n as _);
            }
            Decl::TsModule { 0: _0 } => {
                self.visit_ts_module_decl(&*_0, n as _);
            }
        }
    }
     // .. LOTS of generated methods
}

where Node is declared as

pub trait Node: Any {}
impl<T: ?Sized> Node for T where T: Any {}

cc @ry @bartlomieju

[bartlomieju]

@kdy1 I tried Visit in local checkout of your branch, a few questions arise:
Say I want to override some method to do custom processing:

impl Visit for LintContext {
  fn visit_module(&self, module: &Module, parent: &dyn Node) {
    assert!(self.scope_stack.is_empty());

    let module_node = Box::new(AstNode::Module(module.clone()));
    let current_scope = self.get_current_scope();

    let module_scope = Rc::new(RefCell::new(Scope::new(
      module_node.clone(),
      ScopeKind::Module,
      Some(current_scope.clone()),
    )));

    // Entering module scope
    self.scope_stack.push(module_scope);

    // Call default implementation and walk children
    // NOTE: this doesn't work 
    Visit::visit_module(self, module, parent);

    // Exiting module scope
    self.scope_stack.pop();
  }
}

How do I go about calling default implementation of visit_module(AFAIK that's not possible in Rust)?
Is it possible to do something like self.visit_children(module)?

[kdy1]

@bartlomieju It can be solved by extracting default behavior as a function.

It would be like

pub trait Visit {
    fn visit_module(&mut self, n: &Module, parent: &dyn Node) {
        visit_module(self, n, parent)
    }
}

pub fn visit_module<V>(v: &mut V, module: &Module, parent: &Node) {
     // default implementation lives here
}

I'll do it tomorrow (well, actually it's today for me as it's over 12pm).

[bartlomieju]

@kdy1 awesome, thank you!

[kdy1]

@bartlomieju I did it. Can you check it, please?

[bartlomieju]

@kdy1 any chance you could release it today?

[kdy1]

@bartlomieju I published it.

[bartlomieju]

@kdy1 kudos!