public DirectCompilerResult withFD(DirectCompilerResult from) { this.fieldDeclarations.addAll(from.getFieldDeclarations()); return this; }
public static Set<FieldDeclaration> mergeFDs( List<DirectCompilerResult> sets ) { Set<FieldDeclaration> result = new HashSet<>(); for ( DirectCompilerResult fs : sets ) { result.addAll(fs.getFieldDeclarations()); } return result; }
private boolean isNumericConstant(DirectCompilerResult r) { // might a bit arbitrary, if necessary we should turn this into a flag in `r` return r.getExpression().isNameExpr() && r.resultType.equals(BuiltInType.NUMBER) && r.getFieldDeclarations().size() > 0; }
public String getSourceForUnaryTest(String packageName, String className, String feelExpression, DirectCompilerResult directResult) { return getSourceForUnaryTest(packageName, className, feelExpression, directResult.getExpression(), directResult.getFieldDeclarations()); }
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 visit(ForExpressionNode n) { DirectCompilerResult expr = n.getExpression().accept(this); HashSet<FieldDeclaration> fds = new HashSet<>(); Expressions.NamedLambda namedLambda = Expressions.namedLambda( expr.getExpression(), n.getExpression().getText()); fds.add(namedLambda.field()); fds.addAll(expr.getFieldDeclarations()); List<Expression> expressions = n.getIterationContexts() .stream() .map(iter -> iter.accept(this)) .peek(r -> fds.addAll(r.getFieldDeclarations())) .map(DirectCompilerResult::getExpression) .collect(Collectors.toList()); // .satisfies(expr) return DirectCompilerResult.of( Expressions.ffor(expressions, namedLambda.name()), expr.resultType, fds); }
@Override public DirectCompilerResult visit(QuantifiedExpressionNode n) { DirectCompilerResult expr = n.getExpression().accept(this); HashSet<FieldDeclaration> fds = new HashSet<>(); Expressions.NamedLambda namedLambda = Expressions.namedLambda( expr.getExpression(), n.getExpression().getText()); fds.add(namedLambda.field()); fds.addAll(expr.getFieldDeclarations()); List<Expression> expressions = n.getIterationContexts() .stream() .map(iter -> iter.accept(this)) .peek(r -> fds.addAll(r.getFieldDeclarations())) .map(DirectCompilerResult::getExpression) .collect(Collectors.toList()); // .satisfies(expr) return DirectCompilerResult.of( Expressions.quantifier(n.getQuantifier(), namedLambda.name(), expressions), expr.resultType, fds); }
@Override public DirectCompilerResult visitSignedUnaryExpressionMinus(FEEL_1_1Parser.SignedUnaryExpressionMinusContext ctx) { DirectCompilerResult unaryExpr = visit(ctx.unaryExpression()); if ( unaryExpr.resultType != BuiltInType.NUMBER ) { throw new IllegalArgumentException("signedunary should be only over a FEEL NUMBER (bigdecimal)."); } // therefore, unaryExpr is a bigdecimal and operator is `-`. MethodCallExpr result = new MethodCallExpr(castToBigDecimal(unaryExpr.getExpression()), "negate"); return DirectCompilerResult.of(result, unaryExpr.resultType, unaryExpr.getFieldDeclarations() ); }
@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 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()); }
@Override public DirectCompilerResult visit(ContextEntryNode n) { DirectCompilerResult key = n.getName().accept(this); DirectCompilerResult value = n.getValue().accept(this); if (key.resultType != BuiltInType.STRING) { throw new IllegalArgumentException( "a Context Entry Key must be a valid FEEL String type"); } String keyText = key.getExpression().asStringLiteralExpr().getValue(); // .setEntry(key, value) MethodCallExpr setEntryContextCall = FeelCtx.setEntry(keyText, value.getExpression()); return DirectCompilerResult.of( setEntryContextCall, value.resultType, value.getFieldDeclarations()); }
@Override public DirectCompilerResult visit(UnaryTestListNode n) { MethodCallExpr expr = Expressions.list(); HashSet<FieldDeclaration> fds = new HashSet<>(); for (BaseNode e : n.getElements()) { DirectCompilerResult r = e.accept(this); fds.addAll(r.getFieldDeclarations()); expr.addArgument(r.getExpression()); } if (n.isNegated()) { Expressions.NamedLambda negated = Expressions.namedUnaryLambda( Expressions.notExists(expr), n.getText()); fds.add(negated.field()); return DirectCompilerResult.of( Expressions.list(negated.name()), BuiltInType.LIST, fds); } else { return DirectCompilerResult.of( expr, BuiltInType.LIST, fds); } }
@Override public DirectCompilerResult visitNamedParameter(FEEL_1_1Parser.NamedParameterContext ctx) { DirectCompilerResult name = visit(ctx.name); DirectCompilerResult value = visit(ctx.value); NodeList<Expression> expressions = new NodeList<>(); expressions.add(name.getExpression()); expressions.add(value.getExpression()); ObjectCreationExpr objectCreationExpr = new ObjectCreationExpr(null, new ClassOrInterfaceType(null, NamedParameter.class.getCanonicalName()), expressions); return DirectCompilerResult.of( objectCreationExpr, BuiltInType.UNKNOWN, value.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; }
private DirectCompilerResult buildNotCall(ParserRuleContext ctx, DirectCompilerResult name, ParseTree params) { if (params.getChildCount() == 1) { DirectCompilerResult parameter = visit(params.getChild(0)); // this is an ambiguous call: defer choice to runtime MethodCallExpr expr = new MethodCallExpr( null, "negateTest", new NodeList<>( parameter.getExpression())); return DirectCompilerResult.of(expr, BuiltInType.UNARY_TEST, parameter.getFieldDeclarations()); } else { DirectCompilerResult parameters = visit(params); // if childcount != 1 assume not expression return createUnaryTestExpression(ctx, parameters, UnaryOperator.NOT); } }
private CompiledFEELUnaryTests parse(String input, Map<String, Type> inputTypes, FEELEventListenersManager mgr, CompiledFEELSupport.SyntaxErrorListener listener) { FEEL_1_1Parser parser = FEELParser.parse(mgr, input, inputTypes, Collections.emptyMap(), Collections.emptyList(), Collections.emptyList()); ParseTree tree = parser.unaryTestsRoot(); DirectCompilerResult directResult; if (listener.isError()) { directResult = CompiledFEELSupport.compiledErrorUnaryTest(listener.event().getMessage()); } else { ASTBuilderVisitor v = new ASTBuilderVisitor(inputTypes); BaseNode node = v.visit(tree); BaseNode transformed = node.accept(new ASTUnaryTestTransform()).node(); directResult = transformed.accept(new ASTCompilerVisitor()); } Expression expr = directResult.getExpression(); CompiledFEELUnaryTests cu = new CompilerBytecodeLoader().makeFromJPUnaryTestsExpression(input, expr, directResult.getFieldDeclarations()); return cu; }