default all rule refs to have labels in _localctx with same name with option to turn off

[parrt]

RuleContext object labels:

e : e '+' egets labels e1 and e2
a : e (',' e)*gets List e and NO e1, e2

Rules with multiple alternatives and non-unique elements, get no automatic labels. The reason is, you can get rules like this
a : ID+ | ID ;

have to label alt or element. even for e : expr '++' | expr '--' ;

-Xno-auto-ctx-labels option or something like that to turn off all of this overhead? better name?

Try to get labeled alt labels into alt context.

don't forget to sort out list vs regular labels. ID+ gets ID and ID_list but ID should be the list now.

[parrt]

Sam points out better to have getters to avoid fields. most of time fast enough. Add:

getA() -> single element, or list
getA(i) -> single at ith position

no need for -Xno-auto-ctx-labels

[parrt]

Ok, got Sam's idea in for getters. from

    statement
        : block
        |   ASSERT expression (':' expression)? ';'
        |   'if' parExpression statement ('else' statement)?
        |   'for' '(' forControl ')' statement
        |   'while' parExpression statement
        |   'do' statement 'while' parExpression ';'
        |   'try' block
            ( catches 'finally' block
            | catches
            | 'finally' block
            )
        |   'switch' parExpression '{' switchBlockStatementGroups '}'
        |   'synchronized' parExpression block
        |   'return' expression? ';'
        |   'throw' expression ';'
        |   'break' Identifier? ';'
        |   'continue' Identifier? ';'
        |   ';'
        |   statementExpression ';'
        |   Identifier ':' statement
        ;

we get:

public static class statementContext extends ParserRuleContext<Token> {
    public blockContext block(int i) {
        return (blockContext)getRuleContext(blockContext.class,i);
    }
    public List<expressionContext> expression() {
        return (List<expressionContext>)getRuleContexts(expressionContext.class);
    }
    public parExpressionContext parExpression() {
        return (parExpressionContext)getRuleContext(parExpressionContext.class,0);
    }
    public statementContext statement(int i) {
        return (statementContext)getRuleContext(statementContext.class,i);
    }
    public List<catchesContext> catches() {
        return (List<catchesContext>)getRuleContexts(catchesContext.class);
    }
    public expressionContext expression(int i) {
        return (expressionContext)getRuleContext(expressionContext.class,i);
    }
    public statementExpressionContext statementExpression() {
        return (statementExpressionContext)getRuleContext(statementExpressionContext.class,0);
    }
    public List<blockContext> block() {
        return (List<blockContext>)getRuleContexts(blockContext.class);
    }
    public List<statementContext> statement() {
        return (List<statementContext>)getRuleContexts(statementContext.class);
    }
    public switchBlockStatementGroupsContext switchBlockStatementGroups() {
        return (switchBlockStatementGroupsContext)getRuleContext(switchBlockStatementGroupsContext.class,0);
    }
    public Token ASSERT() { return getToken(JavaLRParser.ASSERT, 0); }
    public forControlContext forControl() {
        return (forControlContext)getRuleContext(forControlContext.class,0);
    }
    public Token Identifier() { return getToken(JavaLRParser.Identifier, 0); }
    public catchesContext catches(int i) {
        return (catchesContext)getRuleContext(catchesContext.class,i);
    }
    public statementContext(ParserRuleContext<Token> parent, int state) {
        super(parent, state);
    }
    @Override
    public void enterRule(ParseTreeListener<Token> listener) {
        if ( listener instanceof JavaLRListener ) ((JavaLRListener)listener).enter(this);
    }
    @Override
    public void exitRule(ParseTreeListener<Token> listener) {
        if ( listener instanceof JavaLRListener ) ((JavaLRListener)listener).exit(this);
    }
}