Wsrtjtyk

I am looking at adding parser alternatives/recovery to to Groovy language grammar: https://github.com/apache/groovy/blob/master/src/main/antlr2/org/codehaus/groovy/antlr/groovy.g

How can I add an alternative to annotationMemberValuePairs that does not cause the parser to bail out of the higher level rules where annotations are optional?

I want to be able to support incomplete annotations like these -- for content assist (code completion) purposes:

@

@Tag(a)

@Tag(a=)

@Tag(a=v,)

I have made modifications that support all but the last. But the trailing comma is giving me fits because annotations are optional in front of a bunch of higher-level rules like the package statement, import statements, type declarations, method declarations, etc.

annotation!  {Token first = LT(1);}

    :   AT! i:identifier nls! ( LPAREN! ( args:annotationArguments )? RPAREN! )?

        {#annotation = #(create(ANNOTATION,"ANNOTATION",first,LT(1)),i,args);}

    // GRECLIPSE add -- allow freestanding '@' for content assist

    |   AT! nls!

        {#annotation = #(create(ANNOTATION,"ANNOTATION",first,LT(1)),missingIdentifier(first,LT(1)),null);}

    // GRECLIPSE end

    ;



annotationsInternal

    :   (

            options{generateAmbigWarnings=false;}:

            {break; /* go out of the ()* loop*/}

            AT "interface"

        |

            annotation nls!

        )*

    ;



annotationsOpt  {Token first = LT(1);}

    :   (

            // See comment above on hushing warnings.

            options{generateAmbigWarnings=false;}:

            annotationsInternal

        )?

        {#annotationsOpt = #(create(ANNOTATIONS,"ANNOTATIONS",first,LT(1)),#annotationsOpt);}

    ;



annotationArguments

    :   v:annotationMemberValueInitializer

        {Token itkn = new Token(IDENT,"value"); AST i; #i = #(create(IDENT,"value",itkn,itkn));

     #annotationArguments = #(create(ANNOTATION_MEMBER_VALUE_PAIR,"ANNOTATION_MEMBER_VALUE_PAIR",LT(1),LT(1)),i,v);}

        | annotationMemberValuePairs

    ;



annotationMemberValuePairs

    :   annotationMemberValuePair ( COMMA! nls! annotationMemberValuePair )*

    ;



annotationMemberValuePair!  {Token first = LT(1);}

    :   i:annotationIdent ( ASSIGN! nls! ( v:annotationMemberValueInitializer )? )?

        {#annotationMemberValuePair = #(create(ANNOTATION_MEMBER_VALUE_PAIR,"ANNOTATION_MEMBER_VALUE_PAIR",first,LT(1)),i,v);}

    ;



annotationIdent

    :   IDENT

    |   keywordPropertyNames

    ;



annotationMemberValueInitializer

    :   conditionalExpression[0] | annotation

    ;

So when I add an alternative to annotationMemberValuePairs like this:

:   annotationMemberValuePair ( COMMA! nls! ( annotationMemberValuePair | RPAREN! {rewind(mark()-1);}) )*

The alternative only works for type declarations, which is at the bottom of a stack of possibilities that all have annotations as optional in a leading position.