Implementation of first suggested solution from #12641.

Split out walking children of AST nodes into separate walk_children_* functions. e.g.:

pub fn walk_block_statement<'a, V: Visit<'a>>(visitor: &mut V, it: &BlockStatement<'a>) {
    let kind = AstKind::BlockStatement(visitor.alloc(it));
    visitor.enter_node(kind);
    walk_children_block_statement(visitor, it);
    visitor.leave_node(kind);
}

pub fn walk_children_block_statement<'a, V: Visit<'a>>(visitor: &mut V, it: &BlockStatement<'a>) {
    visitor.enter_scope(ScopeFlags::empty(), &it.scope_id);
    visitor.visit_span(&it.span);
    visitor.visit_statements(&it.body);
    visitor.leave_scope();
}

Enter/leave scope

enter_scope and leave_scope calls are in walk_children_*, not in walk_*. So if you need some code to run after enter_scope, you'd still need to copy the code from walk_children_* into your Visit::visit_* impl.

Reason is that some AST types enter the scope late, or exit it early. e.g.:

Therefore it's not possible to have enter_scope + leave_scope calls in walk_* functions for all types. I think it'd be confusing if they were in some walk_* functions, but not in others, so have opted not to have them in any walk_* functions for consistency.

Most AST types don't have scopes, so hopefully the walk_children_* functions will still be useful in majority of cases.

Structs only

Only structs have walk_children_* functions, because once changes to AstKind are complete (#11490), no enums will have an AstKind. So walk_* and walk_children_* functions would be equivalent for all enums.