public final NiklausParser.parameters_return parameters() throws RecognitionException {
        NiklausParser.parameters_return retval = new NiklausParser.parameters_return();
        retval.start = input.LT(1);


        CommonTree root_0 = null;

        Token IDENTIFIER61=null;
        Token COMMA62=null;
        Token IDENTIFIER63=null;
        Token COLON64=null;
        Token TYPE65=null;

        CommonTree IDENTIFIER61_tree=null;
        CommonTree COMMA62_tree=null;
        CommonTree IDENTIFIER63_tree=null;
        CommonTree COLON64_tree=null;
        CommonTree TYPE65_tree=null;
        RewriteRuleTokenStream stream_COLON=new RewriteRuleTokenStream(adaptor,"token COLON");
        RewriteRuleTokenStream stream_COMMA=new RewriteRuleTokenStream(adaptor,"token COMMA");
        RewriteRuleTokenStream stream_IDENTIFIER=new RewriteRuleTokenStream(adaptor,"token IDENTIFIER");
        RewriteRuleTokenStream stream_TYPE=new RewriteRuleTokenStream(adaptor,"token TYPE");

        try {
            // C:\\Users\\Edward\\workspace\\ANTLRTest\\src\\Niklaus.g:94:11: ( IDENTIFIER ( COMMA IDENTIFIER )* COLON TYPE -> ( ^( TYPE IDENTIFIER ) )+ )
            // C:\\Users\\Edward\\workspace\\ANTLRTest\\src\\Niklaus.g:95:3: IDENTIFIER ( COMMA IDENTIFIER )* COLON TYPE
            {
            IDENTIFIER61=(Token)match(input,IDENTIFIER,FOLLOW_IDENTIFIER_in_parameters482);  
            stream_IDENTIFIER.add(IDENTIFIER61);


            // C:\\Users\\Edward\\workspace\\ANTLRTest\\src\\Niklaus.g:95:14: ( COMMA IDENTIFIER )*
            loop17:
            do {
                int alt17=2;
                int LA17_0 = input.LA(1);

                if ( (LA17_0==COMMA) ) {
                    alt17=1;
                }


                switch (alt17) {
            	case 1 :
            	    // C:\\Users\\Edward\\workspace\\ANTLRTest\\src\\Niklaus.g:95:15: COMMA IDENTIFIER
            	    {
            	    COMMA62=(Token)match(input,COMMA,FOLLOW_COMMA_in_parameters485);  
            	    stream_COMMA.add(COMMA62);


            	    IDENTIFIER63=(Token)match(input,IDENTIFIER,FOLLOW_IDENTIFIER_in_parameters487);  
            	    stream_IDENTIFIER.add(IDENTIFIER63);


            	    }
            	    break;

            	default :
            	    break loop17;
                }
            } while (true);


            COLON64=(Token)match(input,COLON,FOLLOW_COLON_in_parameters491);  
            stream_COLON.add(COLON64);


            TYPE65=(Token)match(input,TYPE,FOLLOW_TYPE_in_parameters493);  
            stream_TYPE.add(TYPE65);


            // AST REWRITE
            // elements: TYPE, IDENTIFIER
            // token labels: 
            // rule labels: retval
            // token list labels: 
            // rule list labels: 
            // wildcard labels: 
            retval.tree = root_0;
            RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);

            root_0 = (CommonTree)adaptor.nil();
            // 96:3: -> ( ^( TYPE IDENTIFIER ) )+
            {
                if ( !(stream_TYPE.hasNext()||stream_IDENTIFIER.hasNext()) ) {
                    throw new RewriteEarlyExitException();
                }
                while ( stream_TYPE.hasNext()||stream_IDENTIFIER.hasNext() ) {
                    // C:\\Users\\Edward\\workspace\\ANTLRTest\\src\\Niklaus.g:96:6: ^( TYPE IDENTIFIER )
                    {
                    CommonTree root_1 = (CommonTree)adaptor.nil();
                    root_1 = (CommonTree)adaptor.becomeRoot(
                    stream_TYPE.nextNode()
                    , root_1);

                    adaptor.addChild(root_1, 
                    stream_IDENTIFIER.nextNode()
                    );

                    adaptor.addChild(root_0, root_1);
                    }

                }
                stream_TYPE.reset();
                stream_IDENTIFIER.reset();

            }


            retval.tree = root_0;

            }

            retval.stop = input.LT(-1);


            retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }

        finally {
        	// do for sure before leaving
        }
        return retval;
    }