ES3Parser.propertyAssignment C# (CSharp) Method

    public ES3Parser.propertyAssignment_return propertyAssignment() // throws RecognitionException [1]
    {   
        ES3Parser.propertyAssignment_return retval = new ES3Parser.propertyAssignment_return();
        retval.Start = input.LT(1);

        object root_0 = null;

        IToken COLON20 = null;
        ES3Parser.accessor_return acc = default(ES3Parser.accessor_return);

        ES3Parser.propertyName_return prop2 = default(ES3Parser.propertyName_return);

        ES3Parser.formalParameterList_return parameters = default(ES3Parser.formalParameterList_return);

        ES3Parser.functionBody_return statements = default(ES3Parser.functionBody_return);

        ES3Parser.propertyName_return prop1 = default(ES3Parser.propertyName_return);

        ES3Parser.assignmentExpression_return ass = default(ES3Parser.assignmentExpression_return);


        object COLON20_tree=null;


        	retval.value =  new PropertyDeclarationExpression();
        	FunctionExpression func=new FunctionExpression();

        try 
    	{
            // C:\\Users\\s.ros\\Projets\\Jint\\Jint\\ES3.g:1010:2: (acc= accessor prop2= propertyName (parameters= formalParameterList )? statements= functionBody | prop1= propertyName COLON ass= assignmentExpression )
            int alt13 = 2;
            int LA13_0 = input.LA(1);

            if ( (LA13_0 == Identifier) )
            {
                int LA13_1 = input.LA(2);

                if ( (LA13_1 == COLON) )
                {
                    alt13 = 2;
                }
                else if ( ((LA13_1 >= Identifier && LA13_1 <= StringLiteral) || (LA13_1 >= DecimalLiteral && LA13_1 <= HexIntegerLiteral)) )
                {
                    alt13 = 1;
                }
                else 
                {
                    NoViableAltException nvae_d13s1 =
                        new NoViableAltException("", 13, 1, input);

                    throw nvae_d13s1;
                }
            }
            else if ( (LA13_0 == StringLiteral || (LA13_0 >= DecimalLiteral && LA13_0 <= HexIntegerLiteral)) )
            {
                alt13 = 2;
            }
            else 
            {
                NoViableAltException nvae_d13s0 =
                    new NoViableAltException("", 13, 0, input);

                throw nvae_d13s0;
            }
            switch (alt13) 
            {
                case 1 :
                    // C:\\Users\\s.ros\\Projets\\Jint\\Jint\\ES3.g:1010:4: acc= accessor prop2= propertyName (parameters= formalParameterList )? statements= functionBody
                    {
                    	root_0 = (object)adaptor.GetNilNode();

                    	PushFollow(FOLLOW_accessor_in_propertyAssignment3391);
                    	acc = accessor();
                    	state.followingStackPointer--;

                    	adaptor.AddChild(root_0, acc.Tree);
                    	 retval.value.Mode=acc.value; 
                    	 retval.value.Expression=func; 
                    	PushFollow(FOLLOW_propertyName_in_propertyAssignment3399);
                    	prop2 = propertyName();
                    	state.followingStackPointer--;

                    	adaptor.AddChild(root_0, prop2.Tree);
                    	 retval.value.Name=func.Name=prop2.value; 
                    	// C:\\Users\\s.ros\\Projets\\Jint\\Jint\\ES3.g:1010:130: (parameters= formalParameterList )?
                    	int alt12 = 2;
                    	int LA12_0 = input.LA(1);

                    	if ( (LA12_0 == LPAREN) )
                    	{
                    	    alt12 = 1;
                    	}
                    	switch (alt12) 
                    	{
                    	    case 1 :
                    	        // C:\\Users\\s.ros\\Projets\\Jint\\Jint\\ES3.g:1010:131: parameters= formalParameterList
                    	        {
                    	        	PushFollow(FOLLOW_formalParameterList_in_propertyAssignment3406);
                    	        	parameters = formalParameterList();
                    	        	state.followingStackPointer--;

                    	        	adaptor.AddChild(root_0, parameters.Tree);
                    	        	 func.Parameters.AddRange(parameters.value); 

                    	        }
                    	        break;

                    	}

                    	PushFollow(FOLLOW_functionBody_in_propertyAssignment3414);
                    	statements = functionBody();
                    	state.followingStackPointer--;

                    	adaptor.AddChild(root_0, statements.Tree);
                    	 func.Statement=statements.value; 

                    }
                    break;
                case 2 :
                    // C:\\Users\\s.ros\\Projets\\Jint\\Jint\\ES3.g:1011:4: prop1= propertyName COLON ass= assignmentExpression
                    {
                    	root_0 = (object)adaptor.GetNilNode();

                    	PushFollow(FOLLOW_propertyName_in_propertyAssignment3424);
                    	prop1 = propertyName();
                    	state.followingStackPointer--;

                    	adaptor.AddChild(root_0, prop1.Tree);
                    	 retval.value.Name=prop1.value; 
                    	COLON20=(IToken)Match(input,COLON,FOLLOW_COLON_in_propertyAssignment3428); 
                    		COLON20_tree = (object)adaptor.Create(COLON20);
                    		adaptor.AddChild(root_0, COLON20_tree);

                    	PushFollow(FOLLOW_assignmentExpression_in_propertyAssignment3432);
                    	ass = assignmentExpression();
                    	state.followingStackPointer--;

                    	adaptor.AddChild(root_0, ass.Tree);
                    	 retval.value.Expression=ass.value; 

                    }
                    break;

            }
            retval.Stop = input.LT(-1);

            	retval.Tree = (object)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (object)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);

        }
        finally 
    	{
        }
        return retval;
    }
    // $ANTLR end "propertyAssignment"