Confused by alternative labels

[Korporal]

Take a look at this grammar snippet:

passiveStmt
  : declareStmt         # Declaration
  | defineStmt          # Definition
  | procedureRule       # Procedure
  | functionRule        # Function
  | nullStmt            # Null
  ;

When I run this through Antler to gen C# Visitor/Listener, I see these two classes:

and

I'm not really clear on what I should expect but seeing a class named after declareStmt and another after it's label Declaration is driving my brain crazy trying to make sense of it!

[kaby76]

The generated code is correct. You will get additional classes and methods defined for the alt labels. Alt labels serve as a convenience in identifying which alt is used in the parse. They come in handy in avoiding if-then-elsif-else-end statements to handle the various alts.

But, they aren't necessary. One can usually find some identifying structure of the children that quickly sort out what alt applies. For tree traverse engines like XPath, it's not necessary. Further, you are constrained to define a label for all alts whether you need them or not.

[Korporal]

@kaby76 - OK thanks for that help, so I have another question now. In my (very draft) visitor overrides I have this:

        public override AstNode VisitTranslationUnit([NotNull] TranslationUnitContext context)
        {
            var ast_translation_unit_node = new AstTranslationUnit(context);

            foreach (ScopeContext scope in context.scope())
            {
                var astScope = AstScope.Create(scope);

                ast_translation_unit_node.AddScope(astScope);

                var blck = VisitScope(scope);

                if (blck != null)
                    astScope.AddStmtBlock(blck);

            }

            return ast_translation_unit_node;
        }
        public override AstNode VisitScope([NotNull] ScopeContext context)
        {
            if (Has(context.passiveStmt, out var block))
            {
                var ast_stmt_block_node = new AstStmtBlock(context.passiveStmt());


                foreach (DeclareStmtContext dcl_ctxt in context.passiveStmt().Select(s => s.declareStmt()).Where(s => s != null))
                {
                    var ast_declaration_node = new AstDeclaration(dcl_ctxt);

                    ast_stmt_block_node.AddStatement(ast_declaration_node);

                    dcl_ctxt.Node = ast_declaration_node;

                    VisitDeclareStmt(dcl_ctxt);
                }

                foreach (DefineStmtContext def_ctxt in context.passiveStmt().Select(s => s.defineStmt()).Where(s => s != null))
                {
                    var ast_definition_node = new AstDefinition(def_ctxt);

                    ast_stmt_block_node.AddStatement(new AstDefinition(def_ctxt));

                    def_ctxt.Node = ast_definition_node;

                    VisitDefineStmt(def_ctxt);
                }

                return ast_stmt_block_node;
            }

            return null;
        }

You can see that VisitTranslationUnit explicitly calls VisitScope but I understand there's also the generated VisitChildren should I be leveraging that more? and avoid any explicit coupling like this? when would one (if ever) need to make such explicit calls?

A single call to VisitChildren causes multiple calls to VisitScope so how does one in VisitScope represent the fact that there were multiple scopes? what is the result returned by VisitChildren when there were multiple reasults, one from each invocation of VisitScope? In my code above I aggregate the multiple scopes myself, so the VisitChildren is confusing to me.

[kaby76]

VisitChildren should I be leveraging that more?

Generally I don't call VisitChildren(). The problem is that VisitChildren() will call AggregateResult(), and you would then have to override the default implementation. You may as well just call VisitXXXXX(), get the result as you do already, and deal with the aggregation yourself which you already do. Less assumptions, less chance of it breaking.