Examples with VariableDeclarator com.github.javaparser.ast.body.VariableDeclarator used on opensource projects

Example 76 with VariableDeclarator

use of com.github.javaparser.ast.body.VariableDeclarator in project javaparser by javaparser.

the class GenericsResolutionTest method resolveElementOfListAdvancedExample.

@Test
public void resolveElementOfListAdvancedExample() {
    CompilationUnit cu = parseSample("ElementOfList");
    ClassOrInterfaceDeclaration clazz = Navigator.demandClass(cu, "ElementOfList");
    MethodDeclaration method = Navigator.demandMethod(clazz, "annotations");
    VariableDeclarator variableDeclarator = Navigator.demandVariableDeclaration(method, "a").get();
    Expression expression = variableDeclarator.getInitializer().get();
    ResolvedType type = JavaParserFacade.get(new ReflectionTypeSolver()).getType(expression);
    assertEquals(false, type.isTypeVariable());
    assertEquals("AnnotationExpr", type.describe());
}

Example 77 with VariableDeclarator

use of com.github.javaparser.ast.body.VariableDeclarator in project drools by kiegroup.

the class VariableDeclaratorTExpr method toJavaExpression.

@Override
public Node toJavaExpression() {
    Optional<Type> optInitType = initExpression.flatMap(TypedExpression::getType);
    com.github.javaparser.ast.type.Type jpType = toJPType(this.type);
    return initExpression.map(ie -> {
        Expression initializer = (Expression) ie.toJavaExpression();
        // Used to downcast map.get see testAddCastToMapGetOfDeclaration
        if (!optInitType.isPresent() || optInitType.get().equals(Object.class)) {
            initializer = new CastExpr(jpType, new EnclosedExpr(initializer));
        }
        return (Node) new VariableDeclarationExpr(new VariableDeclarator(jpType, name, initializer));
    }).orElse(new VariableDeclarationExpr(jpType, name));
}

Example 78 with VariableDeclarator

use of com.github.javaparser.ast.body.VariableDeclarator in project drools by kiegroup.

the class ForEachDowncastStmtT method toJavaExpression.

@Override
public Node toJavaExpression() {
    ForEachStmt newForEachStmt = new ForEachStmt();
    BlockStmt body = new BlockStmt();
    NodeList<VariableDeclarator> variables = nodeList();
    for (VariableDeclarator v : variableDeclarationExpr.getVariables()) {
        VariableDeclarator newVariable = v.clone();
        String newIteratorVariable = "_" + v.getNameAsString();
        VariableDeclarationExpr castAssign = new VariableDeclarationExpr(new VariableDeclarator(v.getType(), v.getName(), new CastExpr(v.getType(), new NameExpr(newIteratorVariable))));
        body.addStatement(0, castAssign);
        newVariable.setType(Object.class);
        newVariable.setName(newIteratorVariable);
        variables.add(newVariable);
    }
    body.addStatement((BlockStmt) child.toJavaExpression());
    newForEachStmt.setBody(body);
    VariableDeclarationExpr newVariables = new VariableDeclarationExpr(variables);
    newForEachStmt.setVariable(newVariables);
    return new ForEachStmt(newVariables, new NameExpr(iterable), body);
}

Example 79 with VariableDeclarator

use of com.github.javaparser.ast.body.VariableDeclarator in project drools by kiegroup.

the class AccumulateInline method parseInitBlock.

private void parseInitBlock() {
    MethodDeclaration initMethod = getMethodFromTemplateClass("init");
    String mvelBlock = addCurlyBracesToBlock(addSemicolon(accumulateDescr.getInitCode()));
    CompiledBlockResult initCodeCompilationResult = mvelCompiler.compileStatement(mvelBlock);
    BlockStmt initBlock = initCodeCompilationResult.statementResults();
    for (Statement stmt : initBlock.getStatements()) {
        final BlockStmt initMethodBody = initMethod.getBody().orElseThrow(InvalidInlineTemplateException::new);
        if (stmt.isExpressionStmt() && stmt.asExpressionStmt().getExpression().isVariableDeclarationExpr()) {
            VariableDeclarationExpr vdExpr = stmt.asExpressionStmt().getExpression().asVariableDeclarationExpr();
            for (VariableDeclarator vd : vdExpr.getVariables()) {
                final String variableName = vd.getNameAsString();
                contextFieldNames.add(variableName);
                contextData.addField(vd.getType(), variableName, Modifier.publicModifier().getKeyword());
                Optional<Expression> optInitializer = vd.getInitializer();
                optInitializer.ifPresent(initializer -> {
                    Expression target = new FieldAccessExpr(getDataNameExpr(), variableName);
                    Statement initStmt = new ExpressionStmt(new AssignExpr(target, initializer, AssignExpr.Operator.ASSIGN));
                    initMethodBody.addStatement(initStmt);
                    initStmt.findAll(NameExpr.class).stream().map(Node::toString).filter(context::hasDeclaration).forEach(usedExternalDeclarations::add);
                });
                accumulateDeclarations.add(new DeclarationSpec(variableName, DrlxParseUtil.getClassFromContext(context.getTypeResolver(), vd.getType().asString())));
            }
        }
    }
}

Example 80 with VariableDeclarator

use of com.github.javaparser.ast.body.VariableDeclarator in project drools by kiegroup.

the class Consequence method rewriteRHS.

private boolean rewriteRHS(BlockStmt ruleBlock, BlockStmt rhs) {
    AtomicBoolean requireDrools = new AtomicBoolean(false);
    List<MethodCallExpr> methodCallExprs = rhs.findAll(MethodCallExpr.class);
    List<AssignExpr> assignExprs = rhs.findAll(AssignExpr.class);
    List<MethodCallExpr> updateExprs = new ArrayList<>();
    Map<String, Type> rhsBodyDeclarations = new HashMap<>();
    for (VariableDeclarator variableDeclarator : rhs.findAll(VariableDeclarator.class)) {
        rhsBodyDeclarations.put(variableDeclarator.getNameAsString(), variableDeclarator.getType());
    }
    for (MethodCallExpr methodCallExpr : methodCallExprs) {
        if (!methodCallExpr.getScope().isPresent() && isImplicitDroolsMethod(methodCallExpr)) {
            if (methodCallExpr.getNameAsString().equals("insertLogical") && !TruthMaintenanceSystemFactory.present()) {
                context.addCompilationError(new MissingDependencyError(TruthMaintenanceSystemFactory.NO_TMS));
            }
            methodCallExpr.setScope(new NameExpr("drools"));
        }
        if (hasDroolsScope(methodCallExpr) || hasDroolsAsParameter(methodCallExpr)) {
            if (knowledgeHelperMethods.contains(methodCallExpr.getNameAsString())) {
                methodCallExpr.setScope(createAsKnowledgeHelperExpression());
            } else if (methodCallExpr.getNameAsString().equals("update")) {
                if (methodCallExpr.toString().contains("FactHandle")) {
                    methodCallExpr.setScope(new NameExpr("((org.drools.modelcompiler.consequence.DroolsImpl) drools)"));
                }
                updateExprs.add(methodCallExpr);
            } else if (methodCallExpr.getNameAsString().equals("retract")) {
                methodCallExpr.setName(new SimpleName("delete"));
            }
            requireDrools.set(true);
        }
    }
    Set<String> initializedBitmaskFields = new HashSet<>();
    for (MethodCallExpr updateExpr : updateExprs) {
        Expression argExpr = updateExpr.getArgument(0);
        if (argExpr instanceof NameExpr) {
            String updatedVar = ((NameExpr) argExpr).getNameAsString();
            Class<?> updatedClass = classFromRHSDeclarations(rhsBodyDeclarations, updatedVar);
            // We might need to generate the domain metadata class for types used in consequence
            // without an explicit pattern. See CompilerTest.testConsequenceInsertThenUpdate
            context.getPackageModel().registerDomainClass(updatedClass);
            if (context.isPropertyReactive(updatedClass)) {
                if (!initializedBitmaskFields.contains(updatedVar)) {
                    Set<String> modifiedProps = findModifiedProperties(methodCallExprs, updateExpr, updatedVar, updatedClass);
                    modifiedProps.addAll(findModifiedPropertiesFromAssignment(assignExprs, updateExpr, updatedVar, updatedClass));
                    MethodCallExpr bitMaskCreation = createBitMaskInitialization(updatedClass, modifiedProps);
                    AssignExpr bitMaskAssign = createBitMaskField(updatedVar, bitMaskCreation);
                    if (!DrlxParseUtil.hasDuplicateExpr(ruleBlock, bitMaskAssign)) {
                        ruleBlock.addStatement(bitMaskAssign);
                    }
                }
                updateExpr.addArgument("mask_" + updatedVar);
                initializedBitmaskFields.add(updatedVar);
            }
        }
    }
    return requireDrools.get();
}