// $ANTLR start "named_argument"
  // AnnotationParser.g:112:1: named_argument : param= STRING ASIG rhtype -> ^( NAMED_ARG $param
  // rhtype ) ;
  public final AnnotationParser.named_argument_return named_argument() throws RecognitionException {
    AnnotationParser.named_argument_return retval = new AnnotationParser.named_argument_return();
    retval.start = input.LT(1);

    AnnotationCommonTree root_0 = null;

    CommonToken param = null;
    CommonToken ASIG16 = null;
    AnnotationParser.rhtype_return rhtype17 = null;

    AnnotationCommonTree param_tree = null;
    AnnotationCommonTree ASIG16_tree = null;
    RewriteRuleTokenStream stream_ASIG = new RewriteRuleTokenStream(adaptor, "token ASIG");
    RewriteRuleTokenStream stream_STRING = new RewriteRuleTokenStream(adaptor, "token STRING");
    RewriteRuleSubtreeStream stream_rhtype = new RewriteRuleSubtreeStream(adaptor, "rule rhtype");
    try {
      // AnnotationParser.g:113:3: (param= STRING ASIG rhtype -> ^( NAMED_ARG $param rhtype ) )
      // AnnotationParser.g:113:5: param= STRING ASIG rhtype
      {
        param = (CommonToken) match(input, STRING, FOLLOW_STRING_in_named_argument310);
        stream_STRING.add(param);

        ASIG16 = (CommonToken) match(input, ASIG, FOLLOW_ASIG_in_named_argument312);
        stream_ASIG.add(ASIG16);

        pushFollow(FOLLOW_rhtype_in_named_argument314);
        rhtype17 = rhtype();

        state._fsp--;

        stream_rhtype.add(rhtype17.getTree());

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

        root_0 = (AnnotationCommonTree) adaptor.nil();
        // 114:5: -> ^( NAMED_ARG $param rhtype )
        {
          // AnnotationParser.g:114:8: ^( NAMED_ARG $param rhtype )
          {
            AnnotationCommonTree root_1 = (AnnotationCommonTree) adaptor.nil();
            root_1 =
                (AnnotationCommonTree)
                    adaptor.becomeRoot(
                        (AnnotationCommonTree) adaptor.create(NAMED_ARG, "NAMED_ARG"), root_1);

            adaptor.addChild(root_1, stream_param.nextNode());
            adaptor.addChild(root_1, stream_rhtype.nextTree());

            adaptor.addChild(root_0, root_1);
          }
        }

        retval.tree = root_0;
      }

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

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

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

    } finally {
    }
    return retval;
  }
  // $ANTLR start "argument"
  // AnnotationParser.g:102:1: argument : ( literal_argument | named_argument | json );
  public final AnnotationParser.argument_return argument() throws RecognitionException {
    AnnotationParser.argument_return retval = new AnnotationParser.argument_return();
    retval.start = input.LT(1);

    AnnotationCommonTree root_0 = null;

    AnnotationParser.literal_argument_return literal_argument13 = null;

    AnnotationParser.named_argument_return named_argument14 = null;

    AnnotationParser.json_return json15 = null;

    try {
      // AnnotationParser.g:103:1: ( literal_argument | named_argument | json )
      int alt5 = 3;
      switch (input.LA(1)) {
        case STRING_LITERAL:
          {
            alt5 = 1;
          }
          break;
        case STRING:
          {
            alt5 = 2;
          }
          break;
        case JSON_START:
          {
            alt5 = 3;
          }
          break;
        default:
          NoViableAltException nvae = new NoViableAltException("", 5, 0, input);

          throw nvae;
      }

      switch (alt5) {
        case 1:
          // AnnotationParser.g:103:3: literal_argument
          {
            root_0 = (AnnotationCommonTree) adaptor.nil();

            pushFollow(FOLLOW_literal_argument_in_argument260);
            literal_argument13 = literal_argument();

            state._fsp--;

            adaptor.addChild(root_0, literal_argument13.getTree());
          }
          break;
        case 2:
          // AnnotationParser.g:103:22: named_argument
          {
            root_0 = (AnnotationCommonTree) adaptor.nil();

            pushFollow(FOLLOW_named_argument_in_argument264);
            named_argument14 = named_argument();

            state._fsp--;

            adaptor.addChild(root_0, named_argument14.getTree());
          }
          break;
        case 3:
          // AnnotationParser.g:103:39: json
          {
            root_0 = (AnnotationCommonTree) adaptor.nil();

            pushFollow(FOLLOW_json_in_argument268);
            json15 = json();

            state._fsp--;

            adaptor.addChild(root_0, json15.getTree());
          }
          break;
      }
      retval.stop = input.LT(-1);

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

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

    } finally {
    }
    return retval;
  }