private static Parser<List<Expression>> argumentList(Parser<Expression> arg) { return paren(arg.sepBy(term(","))); }
static Parser<Member> constructorDef(Parser<Modifier> mod, Parser<Statement> stmt) { return Parsers.sequence( mod.many(), Terminals.Identifier.PARSER, term("(").next(StatementParser.parameter(mod).sepBy(term(","))).followedBy(term(")")), term("throws").next(TypeLiteralParser.ELEMENT_TYPE_LITERAL.sepBy1(term(","))).optional(), StatementParser.blockStatement(stmt), ConstructorDef::new); }
static Parser<Declaration> enumDef(Parser<Expression> expr, Parser<Member> member) { Parser<EnumDef.Value> enumValue = Parsers.sequence( Terminals.Identifier.PARSER, between(term("("), expr.sepBy(term(",")), term(")")) .optional(), between(term("{"), member.many(), term("}")).optional(), EnumDef.Value::new); return Parsers.sequence( StatementParser.modifier(expr).many(), term("enum").next(Terminals.Identifier.PARSER), term("implements").next(TypeLiteralParser.ELEMENT_TYPE_LITERAL.sepBy1(term(","))).optional(), term("{").next(enumValue.sepBy(term(","))), term(";").next(member.many()).optional().followedBy(term("}")), EnumDef::new); }
static Parser<Expression> functionCall(Parser<Expression> param) { return Parsers.sequence( TerminalParser.QUALIFIED_NAME, paren(param.sepBy(TerminalParser.term(","))), FunctionExpression::new); }
static Parser<Member> methodDef( Parser<Modifier> mod, Parser<Expression> defaultValue, Parser<Statement> stmt) { return Parsers.sequence( mod.many(), TYPE_PARAMETERS.optional(), TypeLiteralParser.TYPE_LITERAL, Terminals.Identifier.PARSER, term("(").next(StatementParser.parameter(mod).sepBy(term(","))).followedBy(term(")")), term("throws").next(TypeLiteralParser.ELEMENT_TYPE_LITERAL.sepBy1(term(","))).optional(), term("default").next(ExpressionParser.arrayInitializerOrRegularExpression(defaultValue)) .optional(), Parsers.or( StatementParser.blockStatement(stmt), term(";").retn((BlockStatement) null)), MethodDef::new); }
static Parser<Expression> tuple(Parser<Expression> expr) { return paren(expr.sepBy(term(","))).map(TupleExpression::new); }
static Parser<Statement> thisCall(Parser<Expression> expr) { return between(phrase("this ("), expr.sepBy(term(",")), phrase(") ;")) .map(ThisCallStatement::new); }
static Parser<Statement> superCall(Parser<Expression> expr) { return between(phrase("super ("), expr.sepBy(term(",")), phrase(") ;")) .map(SuperCallStatement::new); }
static Parser<Expression> newArrayWithoutExplicitLength(Parser<Expression> expr) { return Parsers.sequence( term("new").next(TypeLiteralParser.ARRAY_TYPE_LITERAL), Parsers.between(term("{"), expr.sepBy(term(",")), term("}")), (type, values) -> new NewArrayExpression(type.elementType, null, values)); }
static Parser<Statement> forStatement(Parser<Expression> expr, Parser<Statement> stmt) { return Parsers.sequence( phrase("for (").next(Parsers.or(varStatement(expr), expressionList(expr), NOP)), expr.optional(), between(term(";"), expr.sepBy(term(",")), term(")")), stmt, ForStatement::new); }
static Parser<Expression> newArrayWithExplicitLength(Parser<Expression> expr) { return Parsers.sequence(term("new").next(TypeLiteralParser.TYPE_LITERAL), expr.between(term("["), term("]")), Parsers.between(term("{"), expr.sepBy(term(",")), term("}")).optional(), NewArrayExpression::new); }
static Parser<Annotation> annotation(Parser<Expression> expr) { Parser<Annotation.Element> element = Parsers.sequence( Terminals.Identifier.PARSER.followedBy(term("=")).atomic().optional(), ExpressionParser.arrayInitializerOrRegularExpression(expr), Annotation.Element::new); return Parsers.sequence( term("@").next(TypeLiteralParser.ELEMENT_TYPE_LITERAL), paren(element.sepBy(term(","))).optional(), Annotation::new); }
static Parser<LambdaExpression> lambdaExpression( Parser<Expression> expression, Parser<Statement> stmt) { Parser<LambdaExpression.Parameter> typedParam = Parsers.sequence( TypeLiteralParser.TYPE_LITERAL, Terminals.Identifier.PARSER, LambdaExpression.Parameter::new); Parser<LambdaExpression.Parameter> simpleParam = Terminals.Identifier.PARSER.map(LambdaExpression.Parameter::new); Parser<LambdaExpression.Parameter> lambdaParam = typedParam.or(simpleParam); Parser<List<LambdaExpression.Parameter>> params = paren(lambdaParam.sepBy(term(","))).or(lambdaParam.map(Collections::singletonList)); Parser<Statement> body = StatementParser.blockStatement(stmt).<Statement>cast() .or(expression.map(ExpressionStatement::new)); return Parsers.sequence(params, term("->").next(body), LambdaExpression::new); }