use of org.drools.javaparser.ast.expr.Expression in project drools by kiegroup.
the class ExpressionTyper method castExpr.
private Optional<TypedExpressionCursor> castExpr(CastExpr firstNode, Expression drlxExpr, List<Node> childNodes, boolean isInLineCast, Class<?> originalTypeCursor) {
try {
Type type = firstNode.getType();
Class<?> typeClass = ruleContext.getTypeResolver().resolveType(type.toString());
Optional<TypedExpressionCursor> result = processFirstNode(drlxExpr, childNodes, firstNode.getExpression(), isInLineCast, originalTypeCursor);
return result.map(te -> {
Expression exprWithInlineCast = addCastToExpression(type, te.expressionCursor, isInLineCast);
return new TypedExpressionCursor(exprWithInlineCast, typeClass);
});
} catch (ClassNotFoundException e) {
throw new RuntimeException(e);
}
}
use of org.drools.javaparser.ast.expr.Expression in project drools by kiegroup.
the class ExpressionTyper method methodCallExpr.
private TypedExpressionCursor methodCallExpr(MethodCallExpr methodCallExpr, Class<?> originalTypeCursor, Expression scope) {
methodCallExpr.setScope(scope);
Class[] argsType = new Class[methodCallExpr.getArguments().size()];
for (int i = 0; i < methodCallExpr.getArguments().size(); i++) {
Expression arg = methodCallExpr.getArgument(i);
TypedExpressionResult typedArg = toTypedExpressionFromMethodCallOrField(arg);
TypedExpression typedExpr = typedArg.getTypedExpression().get();
argsType[i] = typedExpr.getType();
methodCallExpr.setArgument(i, typedExpr.getExpression());
}
Class<?> type = ClassUtil.findMethod(originalTypeCursor, methodCallExpr.getNameAsString(), argsType).getReturnType();
return new TypedExpressionCursor(methodCallExpr, type);
}
use of org.drools.javaparser.ast.expr.Expression in project drools by kiegroup.
the class ExpressionTyper method flattenScope.
private static List<Node> flattenScope(Expression expressionWithScope) {
List<Node> res = new ArrayList<>();
if (expressionWithScope instanceof FieldAccessExpr) {
FieldAccessExpr fieldAccessExpr = (FieldAccessExpr) expressionWithScope;
res.addAll(flattenScope(fieldAccessExpr.getScope()));
res.add(fieldAccessExpr.getName());
} else if (expressionWithScope instanceof MethodCallExpr) {
MethodCallExpr methodCallExpr = (MethodCallExpr) expressionWithScope;
if (methodCallExpr.getScope().isPresent()) {
res.addAll(flattenScope(methodCallExpr.getScope().get()));
}
res.add(methodCallExpr.setScope(null));
} else if (expressionWithScope instanceof InlineCastExpr && ((InlineCastExpr) expressionWithScope).getExpression() instanceof FieldAccessExpr) {
InlineCastExpr inlineCastExpr = (InlineCastExpr) expressionWithScope;
Expression internalScope = ((FieldAccessExpr) inlineCastExpr.getExpression()).getScope();
res.addAll(flattenScope((internalScope)));
res.add(expressionWithScope);
} else {
res.add(expressionWithScope);
}
return res;
}
use of org.drools.javaparser.ast.expr.Expression in project drools by kiegroup.
the class ExpressionTyper method toTypedExpressionRec.
private Optional<TypedExpression> toTypedExpressionRec(Expression drlxExpr) {
Class<?> typeCursor = patternType;
if (drlxExpr instanceof EnclosedExpr) {
drlxExpr = ((EnclosedExpr) drlxExpr).getInner();
}
if (drlxExpr instanceof UnaryExpr) {
UnaryExpr unaryExpr = (UnaryExpr) drlxExpr;
Optional<TypedExpression> optTypedExpr = toTypedExpressionRec(unaryExpr.getExpression());
return optTypedExpr.map(typedExpr -> new TypedExpression(new UnaryExpr(typedExpr.getExpression(), unaryExpr.getOperator()), typedExpr.getType()));
} else if (drlxExpr instanceof BinaryExpr) {
BinaryExpr binaryExpr = (BinaryExpr) drlxExpr;
BinaryExpr.Operator operator = binaryExpr.getOperator();
Optional<TypedExpression> optLeft = toTypedExpressionRec(binaryExpr.getLeft());
Optional<TypedExpression> optRight = toTypedExpressionRec(binaryExpr.getRight());
return optLeft.flatMap(left -> optRight.flatMap(right -> {
final BinaryExpr combo = new BinaryExpr(left.getExpression(), right.getExpression(), operator);
return of(new TypedExpression(combo, left.getType()));
}));
} else if (drlxExpr instanceof HalfBinaryExpr) {
final Expression binaryExpr = trasformHalfBinaryToBinary(drlxExpr);
return toTypedExpressionRec(binaryExpr);
} else if (drlxExpr instanceof LiteralExpr) {
return of(new TypedExpression(drlxExpr, getLiteralExpressionType((LiteralExpr) drlxExpr)));
} else if (drlxExpr instanceof ThisExpr) {
return of(new TypedExpression(new NameExpr("_this"), patternType));
} else if (drlxExpr instanceof CastExpr) {
CastExpr castExpr = (CastExpr) drlxExpr;
toTypedExpressionRec(castExpr.getExpression());
return of(new TypedExpression(castExpr, getClassFromContext(ruleContext.getTypeResolver(), castExpr.getType().asString())));
} else if (drlxExpr instanceof NameExpr) {
String name = drlxExpr.toString();
Optional<DeclarationSpec> decl = ruleContext.getDeclarationById(name);
if (decl.isPresent()) {
// then drlxExpr is a single NameExpr referring to a binding, e.g.: "$p1".
context.addUsedDeclarations(name);
return of(new TypedExpression(drlxExpr, decl.get().getDeclarationClass()));
}
if (ruleContext.getQueryParameters().stream().anyMatch(qp -> qp.getName().equals(name))) {
// then drlxExpr is a single NameExpr referring to a query parameter, e.g.: "$p1".
context.addUsedDeclarations(name);
return of(new TypedExpression(drlxExpr));
} else if (packageModel.getGlobals().containsKey(name)) {
Expression plusThis = new NameExpr(name);
context.addUsedDeclarations(name);
return of(new TypedExpression(plusThis, packageModel.getGlobals().get(name)));
} else {
TypedExpression expression;
try {
expression = nameExprToMethodCallExpr(name, typeCursor, null);
} catch (IllegalArgumentException e) {
if (isPositional || ruleContext.getQueryName().isPresent()) {
String unificationVariable = ruleContext.getOrCreateUnificationId(name);
expression = new TypedExpression(unificationVariable, typeCursor, name);
return of(expression);
}
return Optional.empty();
}
context.addReactOnProperties(name);
Expression plusThis = prepend(new NameExpr("_this"), expression.getExpression());
return of(new TypedExpression(plusThis, expression.getType(), name));
}
} else if (drlxExpr instanceof FieldAccessExpr || drlxExpr instanceof MethodCallExpr) {
return toTypedExpressionFromMethodCallOrField(drlxExpr).getTypedExpression();
} else if (drlxExpr instanceof PointFreeExpr) {
final PointFreeExpr pointFreeExpr = (PointFreeExpr) drlxExpr;
Optional<TypedExpression> optLeft = toTypedExpressionRec(pointFreeExpr.getLeft());
OperatorSpec opSpec = getOperatorSpec(drlxExpr, pointFreeExpr.getRight(), pointFreeExpr.getOperator());
return optLeft.map(left -> new TypedExpression(opSpec.getExpression(ruleContext, pointFreeExpr, left), left.getType()).setStatic(opSpec.isStatic()).setLeft(left));
} else if (drlxExpr instanceof HalfPointFreeExpr) {
final HalfPointFreeExpr halfPointFreeExpr = (HalfPointFreeExpr) drlxExpr;
Expression parentLeft = findLeftLeafOfNameExpr(halfPointFreeExpr.getParentNode().orElseThrow(UnsupportedOperationException::new));
Optional<TypedExpression> optLeft = toTypedExpressionRec(parentLeft);
OperatorSpec opSpec = getOperatorSpec(drlxExpr, halfPointFreeExpr.getRight(), halfPointFreeExpr.getOperator());
final PointFreeExpr transformedToPointFree = new PointFreeExpr(halfPointFreeExpr.getTokenRange().get(), parentLeft, halfPointFreeExpr.getRight(), halfPointFreeExpr.getOperator(), halfPointFreeExpr.isNegated(), halfPointFreeExpr.getArg1(), halfPointFreeExpr.getArg2(), halfPointFreeExpr.getArg3(), halfPointFreeExpr.getArg4());
return optLeft.map(left -> new TypedExpression(opSpec.getExpression(ruleContext, transformedToPointFree, left), left.getType()).setStatic(opSpec.isStatic()).setLeft(left));
}
throw new UnsupportedOperationException();
}
use of org.drools.javaparser.ast.expr.Expression in project drools by kiegroup.
the class FromVisitor method createFromCall.
private Expression createFromCall(String expression, Optional<String> optContainsBinding, String bindingId) {
MethodCallExpr fromCall = new MethodCallExpr(null, FROM_CALL);
fromCall.addArgument(new NameExpr(toVar(bindingId)));
if (optContainsBinding.isPresent()) {
DeclarationSpec declarationSpec = ruleContext.getDeclarationById(bindingId).orElseThrow(RuntimeException::new);
Class<?> clazz = declarationSpec.getDeclarationClass();
DrlxParseResult drlxParseResult = new ConstraintParser(ruleContext, packageModel).drlxParse(clazz, bindingId, expression);
drlxParseResult.accept(drlxParseSuccess -> {
Expression parsedExpression = drlxParseSuccess.getExpr();
Expression exprArg = generateLambdaWithoutParameters(drlxParseSuccess.getUsedDeclarations(), parsedExpression);
fromCall.addArgument(exprArg);
});
}
return fromCall;
}
Aggregations