Grammar ambiguity

(
    'OpenParenthesis'
    [ "ArgumentList<@ out argumentList @>" ] 
    'CloseParenthesis'
)
| (
    "ArgumentList<@ out argumentList @>"
)

                | (
                    <!-- ParenthesizedExpression -->
          
                    'OpenParenthesis'
                    "Expression<@ out expression @>"
                    'CloseParenthesis'
                    <%
                        expression = new ParenthesizedExpression(expression, new TextRange(startOffset, this.Token.EndOffset));
                    %>                    
                )
....
| "InvocationExpression<@ ref expression @>"

Production 'InvocationExpression' contains an alternation that has multiple references to the terminal 'OpenParenthesis', either directly or via a non-terminal first set.

The alternation node's stack within the production was:
Concatenation [3 children] - First child: UserCode [// NOTE: The real invocation e])
Alternation [3 children] - First child: Concatenation [3 children] - First child: 'OpenParenthesis' (Terminal)))

The first alternation option node with the terminal was:
Concatenation [3 children] - First child: 'OpenParenthesis' (Terminal))

The second alternation option node with the terminal was:
Concatenation [1 children] - First child: "ArgumentList" (NonTerminal))

    (
       'OpenParenthesis'
       [ "ArgumentList<@ out argumentList @>" ] 
       'CloseParenthesis'
    )
    | (
       "ArgumentList<@ out argumentList @>"
    )
    | "StatementTerminator<- ->"

    <NonTerminal Key="InvocationExpression" Parameters="bool callFound, ref Expression expression">
      <AdditionalConditions>
        <ExpressionCondition>this.IsInvocationExpression(callFound)</ExpressionCondition>
      </AdditionalConditions>
      <Production>
        <![CDATA[
                <%
                    // NOTE: The real invocation expression parses an Expression first but it is up to the caller to supply that
                    int startOffset = expression.StartOffset;
                    expression = new InvocationExpression(expression);
                    expression.StartOffset = startOffset;
                    AstNodeList argumentList = null;
                    bool hasParenthisis = false;
                %>
        
                (
                    ['OpenParenthesis<+ hasParenthisis = true; +>']
                     [ "ArgumentList<@ out argumentList @>" ]
                    [<? hasParenthisis ?>'CloseParenthesis']
                )
             | "StatementTerminator<- ->"
        
                <%
                    if (argumentList != null)
                        ((InvocationExpression)expression).Arguments.AddRange(argumentList.ToArray());
                    expression.EndOffset = this.Token.EndOffset;
                %>
            ]]>
      </Production>
    </NonTerminal>

Function Add(x, y)
Add = x + y
End Function

Sub Test
dim a,b

a = Add(b,2)
End Sub

Function ANumber
  ANumber = 2
End Function

Sub ShowMessage(line1,line2)
  msgbox line1 & vbCRLF & line2
End Sub 
 

Function Add(a,b)
 Add = a + b
End Function

Sub Main
  Dim a
  a = ANumber + 1 
  msgbox "The result is" & a  
  a = Add(1,2) 
  a = Add(ANumber,1)
  Add 1,2  
  Call Add(2,2) 'Call required if parenthesis used
  ShowMessage "Line1","Line2"
  Call ShowMessage("Line1","Line2")

End Sub

a = ANumber + 1

Add 1,2

ShowMessage "Line1","Line2"

function a()
  a = 3
end function

msgbox a + 3