private ExpressionSyntax ParsePostFixExpression(ExpressionSyntax expr)
        {
            Debug.Assert(expr != null);

            while (true)
            {
                SyntaxKind tk = this.CurrentToken.Kind;
                switch (tk)
                {
                case SyntaxKind.OpenParenToken:
                    expr = _syntaxFactory.InvocationExpression(expr, this.ParseParenthesizedArgumentList());
                    break;

                case SyntaxKind.OpenBracketToken:
                    expr = _syntaxFactory.ElementAccessExpression(expr, this.ParseBracketedArgumentList());
                    break;

                case SyntaxKind.PlusPlusToken:
                case SyntaxKind.MinusMinusToken:
                    expr = _syntaxFactory.PostfixUnaryExpression(SyntaxKindFacts.GetPostfixUnaryExpression(tk), expr, this.EatToken());
                    break;

                case SyntaxKind.ColonColonToken:
                    if (this.PeekToken(1).Kind == SyntaxKind.IdentifierToken)
                    {
                        // replace :: with missing dot and annotate with skipped text "::" and error
                        var ccToken = this.EatToken();
                        ccToken = this.AddError(ccToken, ErrorCode.ERR_UnexpectedAliasedName);
                        var dotToken = this.ConvertToMissingWithTrailingTrivia(ccToken, SyntaxKind.DotToken);
                        expr = _syntaxFactory.MemberAccessExpression(
                            expr,
                            dotToken,
                            this.ParseSimpleName(NameOptions.InExpression));
                    }
                    else
                    {
                        // just some random trailing :: ?
                        expr = AddTrailingSkippedSyntax(expr, this.EatTokenWithPrejudice(SyntaxKind.DotToken));
                    }
                    break;

                //case SyntaxKind.MinusGreaterThanToken:
                //	expr = _syntaxFactory.MemberAccessExpression(SyntaxKind.PointerMemberAccessExpression,
                //		expr,
                //		this.EatToken(),
                //		this.ParseSimpleName(NameOptions.InExpression));
                //	break;
                case SyntaxKind.DotToken:
                    expr = _syntaxFactory.MemberAccessExpression(
                        expr,
                        this.EatToken(SyntaxKind.DotToken),
                        this.ParseSimpleName(NameOptions.InExpression));
                    break;

                default:
                    return(expr);
                }
            }
        }