code: def visit(self, node):
          
          method = getattr(self, 'visit_' + node.expr_name, self.generic_visit)
  
          # Call that method, and show where in the tree it failed if it blows
          # up.
          try:
              return method(node, [self.visit(n) for n in node])
          except (VisitationError, UndefinedLabel):
              # Don't catch and re-wrap already-wrapped exceptions.
              raise
          except self.unwrapped_exceptions:
              raise
          except Exception:
              # Catch any exception, and tack on a parse tree so it's easier to
              # see where it went wrong.
              exc_class, exc, tb = exc_info()
              reraise(VisitationError, VisitationError(exc, exc_class, node), tb)
docs: Walk a parse tree, transforming it into another representation.
  
          Recursively descend a parse tree, dispatching to the method named after
          the rule in the :class:`~parsimonious.grammar.Grammar` that produced
          each node. If, for example, a rule was... ::
  
              bold = '<b>'
  
          ...the ``visit_bold()`` method would be called. It is your
          responsibility to subclass :class:`NodeVisitor` and implement those
          methods.