Walking the tree top-down while passing arguments to child nodes recursively

https://github.com/lark-parser/lark/issues/252 shows that the lark.Interpreter can be used to traverse lark.Tree top-down.

The language whose AST I want to work on requires me to collect some information before I can transform/reduce the source code to the final format:

domain A:
   def a():
       pass

   def b():
       pass

I need an to traverse this in a way that gives me a dictionary with the function names:

>>>domains
{"A":["a", "b"]}

Something like this:

domains = {}

class Unknown(lark.???):
    def domain(self, node):
        # Where node.value is then "A", for example
        domains[node.value] = []
        self.visit_children(node, arg=node.value)

    def function(self, node, arg):
        domains[arg].append(node.value)

The bottom-up lark.Visitor and lark.Transformer do not allow accessing parent node information from the child, so I cannot use them.

[erezsh]

@void4 Is this basically for a namespace lookup?

Also, you can shape the tree in the grammar, like with ?name: .. to collapse nodes with a single child, so you won’t have to do things like children[0]

[MegaIng]

Does something speak against storing the ‘arguments’/environment as a class attribute of the Interpreter subclass?

class TypeGetter(Interpreter):
    def start(self, node):
        self.visit_children(node)
        if DEBUG:
            print("Collected type definitions and function signatures.")

    def domaindef(self, node):
        self.domainname = node.children[0].children[0].value
        self.visit_children(node)

    def funcdef(self, node):
        domains[self.domainname][getChildByName(node, "funname").children[0].value] = {...}