public static MethodCallExpr closeContext(DirectCompilerResult contextEntriesMethodChain) { return new MethodCallExpr( contextEntriesMethodChain.getExpression(), "closeContext"); }
public CompilationUnit getSourceCode() { DirectCompilerResult compilerResult = getCompilerResult(); return compiler.getCompilationUnit( CompiledFEELUnaryTests.class, TEMPLATE_RESOURCE, packageName, TEMPLATE_CLASS, expression, compilerResult.getExpression(), compilerResult.getFieldDeclarations()); }
public CompilationUnit getSourceCode() { DirectCompilerResult compilerResult = getCompilerResult(); return compiler.getCompilationUnit( CompiledFEELExpression.class, TEMPLATE_RESOURCE, packageName, TEMPLATE_CLASS, expression, compilerResult.getExpression(), compilerResult.getFieldDeclarations()); }
@Override public DirectCompilerResult visitRelExpressionInstanceOf(FEEL_1_1Parser.RelExpressionInstanceOfContext ctx) { DirectCompilerResult expr = visit(ctx.val); DirectCompilerResult type = visit(ctx.type()); MethodCallExpr isInstanceOfCall = new MethodCallExpr(type.getExpression(), "isInstanceOf"); isInstanceOfCall.addArgument(expr.getExpression()); return DirectCompilerResult.of(isInstanceOfCall, BuiltInType.BOOLEAN, mergeFDs(expr, type)); }
@Override public DirectCompilerResult visit(InstanceOfNode n) { DirectCompilerResult expr = n.getExpression().accept(this); DirectCompilerResult type = n.getType().accept(this); return DirectCompilerResult.of( Expressions.isInstanceOf(expr.getExpression(), type.getExpression()), BuiltInType.BOOLEAN, mergeFDs(expr, type)); }
@Override public DirectCompilerResult visit(NamedParameterNode n) { DirectCompilerResult name = n.getName().accept(this); DirectCompilerResult expr = n.getExpression().accept(this); return DirectCompilerResult.of( Expressions.namedParameter(name.getExpression(), expr.getExpression()), BuiltInType.UNKNOWN).withFD(name).withFD(expr); }
@Override public DirectCompilerResult visitCondOr(FEEL_1_1Parser.CondOrContext ctx) { DirectCompilerResult left = visit( ctx.left ); DirectCompilerResult right = visit( ctx.right ); MethodCallExpr result = new MethodCallExpr(null, "or"); result.addArgument(left.getExpression()); result.addArgument(right.getExpression()); return DirectCompilerResult.of(result, BuiltInType.BOOLEAN).withFD(left).withFD(right); }
@Override public DirectCompilerResult visit(FunctionInvocationNode n) { DirectCompilerResult functionName = n.getName().accept(this); DirectCompilerResult params = n.getParams().accept(this); return DirectCompilerResult.of( Expressions.invoke(functionName.getExpression(), params.getExpression()), functionName.resultType) .withFD(functionName) .withFD(params); }
@Override public DirectCompilerResult visitCondAnd(FEEL_1_1Parser.CondAndContext ctx) { DirectCompilerResult left = visit( ctx.left ); DirectCompilerResult right = visit( ctx.right ); MethodCallExpr result = new MethodCallExpr(null, "and"); result.addArgument(left.getExpression()); result.addArgument(right.getExpression()); return DirectCompilerResult.of(result, BuiltInType.BOOLEAN).withFD(left).withFD(right); }
@Override public DirectCompilerResult visit(InfixOpNode n) { DirectCompilerResult left = n.getLeft().accept(this); DirectCompilerResult right = n.getRight().accept(this); MethodCallExpr expr = Expressions.binary( n.getOperator(), left.getExpression(), right.getExpression()); return DirectCompilerResult.of(expr, BuiltInType.UNKNOWN).withFD(left).withFD(right); }
private DirectCompilerResult buildFunctionCall(ParserRuleContext ctx, DirectCompilerResult name, ParseTree params) { DirectCompilerResult parameters = visit(params); MethodCallExpr invokeCall = new MethodCallExpr(new NameExpr(CompiledFEELSupport.class.getSimpleName()), "invoke"); invokeCall.addArgument(new NameExpr("feelExprCtx")); invokeCall.addArgument(name.getExpression()); invokeCall.addArgument(parameters.getExpression()); return DirectCompilerResult.of(invokeCall, name.resultType).withFD(name).withFD(parameters); }
@Override public DirectCompilerResult visitPrimaryParens(FEEL_1_1Parser.PrimaryParensContext ctx) { DirectCompilerResult expr = visit( ctx.expression() ); EnclosedExpr result = new EnclosedExpr(expr.getExpression()); return DirectCompilerResult.of(result, expr.resultType, expr.getFieldDeclarations()); }
@Override public DirectCompilerResult visit(SignedUnaryNode n) { DirectCompilerResult result = n.getExpression().accept(this); if (n.getSign() == SignedUnaryNode.Sign.NEGATIVE) { return DirectCompilerResult.of( Expressions.negate(result.getExpression()), result.resultType, result.getFieldDeclarations()); } else { return result; } }
@Override public DirectCompilerResult visitUnaryTests_empty(FEEL_1_1Parser.UnaryTests_emptyContext ctx) { DirectCompilerResult t = createEmptyUnaryTestExpression(); MethodCallExpr list = new MethodCallExpr( null, "list", new NodeList<>(t.getExpression())); return DirectCompilerResult.of(list, BuiltInType.LIST, t.getFieldDeclarations()); }
@Override public DirectCompilerResult visit(ListNode n) { MethodCallExpr list = Expressions.list(); DirectCompilerResult result = DirectCompilerResult.of(list, BuiltInType.LIST); for (BaseNode e : n.getElements()) { DirectCompilerResult r = e.accept(this); result.withFD(r.getFieldDeclarations()); list.addArgument(r.getExpression()); } return result; }
@Override public DirectCompilerResult visit(FilterExpressionNode n) { DirectCompilerResult expr = n.getExpression().accept(this); DirectCompilerResult filter = n.getFilter().accept(this); Expressions.NamedLambda lambda = Expressions.namedLambda(filter.getExpression(), n.getFilter().getText()); DirectCompilerResult r = DirectCompilerResult.of( Expressions.filter(expr.getExpression(), lambda.name()), // here we could still try to infer the result type, but presently use ANY BuiltInType.UNKNOWN).withFD(expr).withFD(filter); r.addFieldDesclaration(lambda.field()); return r; }
private DirectCompilerResult telescopePathAccessor(DirectCompilerResult scopeExpr, List<String> names) { MethodCallExpr pathCall = new MethodCallExpr(new NameExpr(CompiledFEELSupport.class.getSimpleName()), "path"); pathCall.addArgument(new NameExpr("feelExprCtx")); pathCall.addArgument(scopeExpr.getExpression()); MethodCallExpr filterPathCall = new MethodCallExpr(pathCall, "with"); for (String n : names) { filterPathCall.addArgument(new StringLiteralExpr(n)); } // here I could still try to infer the result type, but presently use ANY return DirectCompilerResult.of(filterPathCall, BuiltInType.UNKNOWN).withFD(scopeExpr); }
@Override public DirectCompilerResult visitUnaryTests_negated(FEEL_1_1Parser.UnaryTests_negatedContext ctx) { DirectCompilerResult positiveTests = doPositiveUnaryTests(ctx.positiveUnaryTests()); DirectCompilerResult result = createUnaryTestExpression(ctx, positiveTests, UnaryOperator.NOT); MethodCallExpr expression = new MethodCallExpr( null, "list", new NodeList<>(result.getExpression())); return DirectCompilerResult.of(expression, BuiltInType.UNARY_TEST, result.getFieldDeclarations()); }
private CompiledFEELExpression parse(String input, Map<String, Type> inputTypes) { FEEL_1_1Parser parser = FEELParser.parse(null, input, inputTypes, Collections.emptyMap(), Collections.emptyList(), Collections.emptyList()); ParseTree tree = parser.compilation_unit(); ASTBuilderVisitor v = new ASTBuilderVisitor(inputTypes); BaseNode node = v.visit(tree); DirectCompilerResult directResult = node.accept(new ASTCompilerVisitor()); Expression expr = directResult.getExpression(); CompiledFEELExpression cu = new CompilerBytecodeLoader().makeFromJPExpression(input, expr, directResult.getFieldDeclarations()); return cu; }
@Override public DirectCompilerResult visit(UnaryTestNode n) { DirectCompilerResult value = n.getValue().accept(this); Expression expr = Expressions.unary(n.getOperator(), value.getExpression()); Expressions.NamedLambda namedLambda = Expressions.namedUnaryLambda(expr, n.getText()); DirectCompilerResult r = DirectCompilerResult.of(namedLambda.name(), BuiltInType.UNARY_TEST) .withFD(value); r.addFieldDesclaration(namedLambda.field()); return r; } }