Java Code Examples for spoon.reflect.code.CtIf#setCondition()

@Override
public CtIf processCondition(CtStatement element, String newCondition) {
    //logger.debug("##### {} ##### Before:\n{}", element, element.getParent());
    // if the element is not a line
    if (!new LineFilter().matches(element)) {
        element = element.getParent(new LineFilter());
    }
    CtElement parent = element.getParent();
    CtIf newIf = element.getFactory().Core().createIf();
    CtCodeSnippetExpression<Boolean> condition = element.getFactory().Core().createCodeSnippetExpression();
    condition.setValue(newCondition);
    newIf.setCondition(condition);
    // Fix : warning: ignoring inconsistent parent for [CtElem1] ( [CtElem2] != [CtElem3] )
    newIf.setParent(parent);
    element.replace(newIf);
    // this should be after the replace to avoid an StackOverflowException caused by the circular reference.
    newIf.setThenStatement(element);
    //logger.debug("##### {} ##### After:\n{}", element, element.getParent().getParent());
    return newIf;
}
 

@SuppressWarnings({ "static-access", "rawtypes", "unchecked" })
public void visitCtIf(CtIf ifElement) {
	 
	super.visitCtIf(ifElement);
	CtExpression  cond = ifElement.getCondition();
	
	CtLiteral<Boolean> literalvalue = this.mutSupporter.getFactory().Core().createLiteral();
	Boolean bval=false;
	literalvalue.setValue(bval);
	
	CtBinaryOperator<?> newcond = this.mutSupporter.getFactory().Core().createBinaryOperator();
	newcond.setKind(BinaryOperatorKind.AND);
	newcond.setRightHandOperand(literalvalue);
	newcond.setLeftHandOperand(cond);
	
	ifElement.setCondition((CtExpression<Boolean>) newcond);
	saveSketchAndSynthesize();
	ifElement.setCondition(cond);
	resoreDiskFile();
}
 

@Override
public boolean applyModification() {

	CtStatement original = (CtStatement) MetaGenerator.geOriginalElement(statementToWrap);
	this.setParentBlock(original.getParent(CtBlock.class));
	//
	CtIf ifNew = MutationSupporter.getFactory().createIf();
	ifNew.setParent(original.getParent());
	CtStatement originalCloned = original.clone();
	MutationSupporter.clearPosition(originalCloned);
	ifNew.setThenStatement(originalCloned);

	// as difference with the meta, here we put the ingredient evaluated in the
	// meta.
	ifNew.setCondition((CtExpression<Boolean>) ifcondition);

	//

	super.setOriginal(original);
	super.setModified(ifNew);
	//

	return super.applyModification();
}
 

private void genAddIfGuard(CtStatement n) {
    CtLiteral<Boolean> placeholder = factory.createLiteral();
    placeholder.setValue(true); // consider the placeholder, should this be more concrete?
    CtUnaryOperator<Boolean> guardCondition = factory.createUnaryOperator();
    guardCondition.setKind(UnaryOperatorKind.NOT);
    guardCondition.setOperand(placeholder);

    CtIf guardIf = factory.createIf();
    guardIf.setParent(n.getParent());
    guardIf.setCondition(guardCondition);
    guardIf.setThenStatement(n.clone());

    Repair repair = new Repair();
    repair.kind = RepairKind.GuardKind;
    repair.isReplace = true;
    repair.srcElem = n;
    repair.dstElem = guardIf;
    repair.atoms.addAll(repairAnalyzer.getCondCandidateVars(n));
    repairs.add(repair);
    // we do not consider the case of if statement as special at all
}
 

private void genLooseCondition(CtIf n) {
    CtExpression<Boolean> oldCondition = n.getCondition();
    CtLiteral<Boolean> placeholder = factory.createLiteral();
    placeholder.setValue(true); // consider the placeholder, should this be more concrete?
    CtBinaryOperator<Boolean> newCondition = factory.createBinaryOperator();
    newCondition.setKind(BinaryOperatorKind.OR);
    newCondition.setLeftHandOperand(oldCondition);
    newCondition.setRightHandOperand(placeholder);

    CtIf S = n.clone();
    S.setParent(n.getParent());
    S.setCondition(newCondition);

    Repair repair = new Repair();
    repair.kind = RepairKind.LoosenConditionKind;
    repair.isReplace = true;
    repair.srcElem = n;
    repair.dstElem = S;
    repair.atoms.addAll(repairAnalyzer.getCondCandidateVars(n));
    repairs.add(repair);
    // we do not consider the case of short-circuit evaluation at all
}
 

private void genTightCondition(CtIf n) {
    CtExpression<Boolean> oldCondition = n.getCondition();
    CtLiteral<Boolean> placeholder = factory.createLiteral();
    placeholder.setValue(true); // consider the placeholder, should this be more concrete?
    CtUnaryOperator<Boolean> tmpCondition = factory.createUnaryOperator();
    tmpCondition.setKind(UnaryOperatorKind.NOT);
    tmpCondition.setOperand(placeholder);
    CtBinaryOperator<Boolean> newCondition = factory.createBinaryOperator();
    newCondition.setKind(BinaryOperatorKind.AND);
    newCondition.setLeftHandOperand(oldCondition);
    newCondition.setRightHandOperand(placeholder);

    CtIf S = n.clone();
    S.setParent(n.getParent());
    S.setCondition(newCondition);

    Repair repair = new Repair();
    repair.kind = RepairKind.TightenConditionKind;
    repair.isReplace = true;
    repair.srcElem = n;
    repair.dstElem = S;
    repair.atoms.addAll(repairAnalyzer.getCondCandidateVars(n));
    repairs.add(repair);
    // we do not consider the case of short-circuit evaluation at all
}
 

public void process(Bound annotation, CtParameter<?> element) {
	final CtMethod parent = element.getParent(CtMethod.class);

	// Build if check for min.
	CtIf anIf = getFactory().Core().createIf();
	anIf.setCondition(getFactory().Code().<Boolean>createCodeSnippetExpression(element.getSimpleName() + " < " + annotation.min()));
	CtThrow throwStmt = getFactory().Core().createThrow();
	throwStmt.setThrownExpression((CtExpression<? extends Throwable>) getFactory().Core().createCodeSnippetExpression().setValue("new RuntimeException(\"out of min bound (\" + " + element.getSimpleName() + " + \" < " + annotation.min() + "\")"));
	anIf.setThenStatement(throwStmt);
	parent.getBody().insertBegin(anIf);
	anIf.setParent(parent);

	// Build if check for max.
	anIf = getFactory().Core().createIf();
	anIf.setCondition(getFactory().Code().<Boolean>createCodeSnippetExpression(element.getSimpleName() + " > " + annotation.max()));
	anIf.setThenStatement(getFactory().Code().createCtThrow("new RuntimeException(\"out of max bound (\" + " + element.getSimpleName() + " + \" > " + annotation.max() + "\")"));
	parent.getBody().insertBegin(anIf);
	anIf.setParent(parent);
}
 

@SuppressWarnings({ "rawtypes", "unchecked", "static-access" })
private CtElement createReturn(CtElement rootElement) {
	CtMethod method = rootElement.getParent(CtMethod.class);

	if (method == null) {
		log.info("Element without method parent");
		return null;
	}
	// We create the "if(true)"{}
	CtIf ifReturn = MutationSupporter.getFactory().Core().createIf();
	CtExpression ifTrueExpression = MutationSupporter.getFactory().Code().createCodeSnippetExpression("true");
	ifReturn.setCondition(ifTrueExpression);

	// Now we create the return statement
	CtReturn<?> returnStatement = null;
	CtTypeReference typeR = method.getType();
	if (typeR == null || "void".equals(typeR.getSimpleName())) {
		returnStatement = MutationSupporter.getFactory().Core().createReturn();
	} else {
		String codeExpression = "";
		if (prim.contains(typeR.getSimpleName())) {
			codeExpression = getZeroValue(typeR.getSimpleName().toLowerCase());
		} else if (typeR.getSimpleName().toLowerCase().equals("boolean")) {
			codeExpression = "false";
		} else {
			codeExpression = "null";
		}
		CtExpression returnExpression = MutationSupporter.getFactory().Code()
				.createCodeSnippetExpression(codeExpression);
		returnStatement = MutationSupporter.getFactory().Core().createReturn();
		returnStatement.setReturnedExpression(returnExpression);
	}
	// Now, we associate if(true){return [...]}
	ifReturn.setThenStatement(returnStatement);
	return ifReturn;

}
 

/**
 * Creates a new if from that one passed as parammeter. The next if has a
 * condition expression expression true or false according to the variable
 * <b>thenBranch</b>
 * 
 * @param ifElement
 * @param thenBranch
 * @return
 */
@SuppressWarnings({ "rawtypes", "unchecked", })
private CtIf createIf(CtIf ifElement, boolean thenBranch) {

	CtIf clonedIf = MutationSupporter.getFactory().Core().clone(ifElement);
	CtExpression ifExpression = MutationSupporter.getFactory().Code()
			.createCodeSnippetExpression(Boolean.toString(thenBranch));

	clonedIf.setCondition(ifExpression);

	return clonedIf;
}
 

public void process(CtStatement element) {
    logger.debug("##### {} ##### Before:\n{}", element, element.getParent());
    CtElement parent = element.getParent();
    CtIf newIf = element.getFactory().Core().createIf();
    CtCodeSnippetExpression<Boolean> condition;
    if (getValue() != null) {
        switch (getValue()) {
            case "1":
                condition = element.getFactory().Code()
                        .createCodeSnippetExpression("true");
                break;
            case "0":
                condition = element.getFactory().Code()
                        .createCodeSnippetExpression("false");
                break;
            default:
                condition = element.getFactory().Code()
                        .createCodeSnippetExpression(getValue());
        }
    } else {
        condition = element
                .getFactory()
                .Code()
                .createCodeSnippetExpression(
                        Debug.class.getCanonicalName()
                                + ".makeSymbolicBoolean(\"guess_fix\")");
    }
    newIf.setCondition(condition);
    // Fix : warning: ignoring inconsistent parent for [CtElem1] ( [CtElem2] != [CtElem3] )
    newIf.setParent(parent);
    element.replace(newIf);
    // this should be after the replace to avoid an StackOverflowException caused by the circular reference.
    newIf.setThenStatement(element);
    // Fix : warning: ignoring inconsistent parent for [CtElem1] ( [CtElem2] != [CtElem3] )
    newIf.getThenStatement().setParent(newIf);
    logger.debug("##### {} ##### After:\n{}", element, element.getParent().getParent());
}
 

@SuppressWarnings({ "static-access", "unchecked", "rawtypes" })
private void writeCondition(String type, CtBlock parent, int id) {
	CtExpression conditionExp = ExpressionGenerator.fetchEXP(this.mutSupporter, this.modificationPoint, type, querytype);
       
	CtIf ifStmt = this.mutSupporter.getFactory().Core().createIf();
	ifStmt.setCondition(conditionExp);
	ifStmt.setThenStatement((CtStatement)this.modificationPoint.getCodeElement());
	parent.addStatement(id, ifStmt);
	parent.removeStatement((CtStatement)this.modificationPoint.getCodeElement());
	saveSketchAndSynthesize();
	parent.addStatement(id, (CtStatement)this.modificationPoint.getCodeElement());
	parent.removeStatement(ifStmt);
	resoreDiskFile();
}
 

@SuppressWarnings({ "rawtypes", "static-access", "unchecked" })
private void writeIfReturn(String type, CtBlock parent, int id) {
	
	CtExpression conditionExp = ExpressionGenerator.fetchEXP(this.mutSupporter, this.modificationPoint, type, querytype);

	CtIf ifstmt = this.mutSupporter.getFactory().Core().createIf();
	ifstmt.setCondition(conditionExp);
	
	CtElement parentmethod=parent;
	
	do {
		parentmethod=parentmethod.getParent();
	} while (!(parentmethod instanceof CtMethod));
	
	String returntype="void";
	returntype=((CtMethod)parentmethod).getType().getQualifiedName();
	returntype = returntype.replaceAll("\\d","");
	
	CtReturn returnstmt = this.mutSupporter.getFactory().Core().createReturn();

	if (!returntype.toLowerCase().equals("void")) {
		CtExpression returnexp = ExpressionGenerator.fetchEXP(this.mutSupporter, this.modificationPoint, returntype, "EXP");
		returnstmt.setReturnedExpression(returnexp);
	}
	
	ifstmt.setThenStatement(returnstmt);
	
	parent.addStatement(id, ifstmt);
	saveSketchAndSynthesize();
	parent.removeStatement(ifstmt);
	resoreDiskFile();
}
 

@SuppressWarnings("unchecked")
@Override
public void visitCtIf(CtIf ifElement) {
	super.visitCtIf(ifElement);
	
	@SuppressWarnings("rawtypes")
	CtExpression exper=ifElement.getCondition();
	if (candidates.containsKey(exper)) {
		ifElement.setCondition(candidates.get(exper));
		saveSketchAndSynthesize();
		ifElement.setCondition(exper);
		resoreDiskFile();
	}
}
 

public static MetaOperatorInstance createMetaStatementReplacement(ModificationPoint modificationPoint,
		CtElement elementSource, CtExpression defaultReturnElement, int variableCounter,
		List<Ingredient> ingredients, List<CtParameter<?>> parameters, List<CtExpression<?>> realParameters,
		AstorOperator parentOperator, CtTypeReference returnType) {

	MetaOperatorInstance opMega = new MetaOperatorInstance((MetaOperator) parentOperator,
			MetaGenerator.getNewIdentifier());

	List<OperatorInstance> opsOfVariant = new ArrayList();
	Map<Integer, Ingredient> ingredientOfMapped = new HashMap<>();

	realParameters = filterParameter(realParameters);
	// Creation of mega method
	CtMethod<?> megaMethod = createMegaMethod(opMega, modificationPoint, defaultReturnElement, variableCounter,
			ingredients, parameters, ingredientOfMapped, returnType);

	CtInvocation newInvocationToMega = creationInvocationToMega(modificationPoint, realParameters, megaMethod);

	// Now the if to be inserted:

	CtIf ifNew = MutationSupporter.getFactory().createIf();

	CtStatement statementPointed = (CtStatement) modificationPoint.getCodeElement();
	CtStatement statementPointedCloned = statementPointed.clone();
	statementPointedCloned.setPosition(new NoSourcePosition());
	MutationSupporter.clearPosition(statementPointedCloned);

	ifNew.setThenStatement(statementPointedCloned);
	ifNew.setCondition(newInvocationToMega);

	// Let's create the operations
	OperatorInstance opInstace = new StatementOperatorInstance(modificationPoint, parentOperator, statementPointed,
			ifNew);
	opsOfVariant.add(opInstace);

	// The meta method to be added
	OperatorInstance opMethodAdd = new OperatorInstance();
	opMethodAdd.setOperationApplied(new InsertMethodOperator());
	opMethodAdd.setOriginal(modificationPoint.getCodeElement());
	opMethodAdd.setModified(megaMethod);
	opMethodAdd.setModificationPoint(modificationPoint);
	opsOfVariant.add(opMethodAdd);

	//
	log.debug("method: \n" + megaMethod);

	log.debug("invocation: \n" + newInvocationToMega);

	opMega.setOperatorInstances(opsOfVariant);
	opMega.setAllIngredients(ingredientOfMapped);
	opMega.setOperationApplied(parentOperator);
	opMega.setOriginal(modificationPoint.getCodeElement());
	opMega.setModificationPoint(modificationPoint);

	return opMega;
}
 

private void mutateOperator(final CtStatement expression) {
	
	
	/*if (alreadyInHotsSpot(expression)) {
		System.out
				.println(String
						.format("Expression '%s' ignored because it is included in previous hot spot",
								expression));
		return;
	}*/
	int thisIndex = ++selectorIndex;
	
	ACTIVABLE kind = ACTIVABLE.ENABLED;
	String expressionContent =  String.format("("+ PREFIX + "%s.is(%s))",
			thisIndex, kind.getClass().getCanonicalName()+"."+kind.name());
	
	//create IfChoice with right condition
	CtIf ifChoice = getFactory().Core().createIf();
	CtCodeSnippetExpression expIf = getFactory().Code().createCodeSnippetExpression(expressionContent);
	ifChoice.setCondition(expIf);
		
	
	
	//create block from a clone of expression
	CtStatement exp2 = getFactory().Core().clone(expression);
	CtBlock thenBlock = getFactory().Code().createCtBlock(exp2);
	
	//set if and replace the expression with the new if
	ifChoice.setThenStatement(thenBlock);
	expression.replace(ifChoice);
	
	//to be sure
	ifChoice.getParent().updateAllParentsBelow();
	
	//if there are return or throws, set else with value of return.
	Filter<CtCFlowBreak> filterReturn = new ReturnOrThrowFilter();
	if(!thenBlock.getElements(filterReturn).isEmpty()){
		SetElseStatementWithReturn(ifChoice);
	}

	
	//to avoid to delete assignement in statement, we assign a default value to all local variable.
	Filter<CtLocalVariable> filterLocalVariable =  new TypeFilter<CtLocalVariable>(CtLocalVariable.class);
	CtMethod method = ifChoice.getParent(CtMethod.class);
	if(method != null && !method.getElements(filterLocalVariable).isEmpty()){
		for(CtLocalVariable var : method.getElements(filterLocalVariable)){
			if(var.getAssignment() == null){
				//create right side expression from template.
				Class classOfAssignment = var.getType().getActualClass();
				CtLiteral rightHand = null;
				
				//Particular case of ForEach (int x : numbers) can't be (int x = 0 : numbers)
				if(var.getParent() instanceof CtForEach){
					continue;
				}
				if(PrimitiveTemplateExpressions.containsKey(classOfAssignment)){
					CtLiteral templateExpression = PrimitiveTemplateExpressions.get(classOfAssignment);
					rightHand = getFactory().Core().clone(templateExpression);
				}else{
					rightHand = getFactory().createLiteral().setValue(null);
				}
				var.setAssignment(rightHand);
			}
		}
	}
	
	Selector.generateSelector(expression, ACTIVABLE.ENABLED, thisIndex, ActivableSet, PREFIX);
	//hotSpots.add(expression);

}
 

@SuppressWarnings({ "rawtypes", "unchecked" })
@Override
public List<OperatorInstance> createOperatorInstances(ModificationPoint modificationPoint, Ingredient ingredient,
		IngredientTransformationStrategy transformationStrategy) {

	List<OperatorInstance> instances = new ArrayList<>();

	List<Ingredient> ingredientsTransformed = transformationStrategy.transform(modificationPoint, ingredient);

	for (Ingredient iIngredient : ingredientsTransformed) {

		CtExpression condition = (CtExpression) iIngredient.getCode();
		CtIf precondition = MutationSupporter.factory.createIf();
		precondition.setCondition(condition);
		precondition.setThenStatement((CtStatement) modificationPoint.getCodeElement().clone());

		OperatorInstance operatorInstance = new StatementOperatorInstance(modificationPoint, this, precondition);

		instances.add(operatorInstance);

	}

	return instances;

}
 

@SuppressWarnings({ "rawtypes", "unchecked" })
@Override
public List<OperatorInstance> createOperatorInstances(ModificationPoint modificationPoint) {

	List<OperatorInstance> instances = new ArrayList<>();

	List<CtVariableAccess> varAccess = VariableResolver.collectVariableAccess(modificationPoint.getCodeElement());

	for (CtVariableAccess iVariableAccess : varAccess) {

		if (!iVariableAccess.getType().isPrimitive()) {

			CtIf precodition = MutationSupporter.factory.createIf();

			CtExpression ifcondition = MutationSupporter.factory.createBinaryOperator(iVariableAccess,
					MutationSupporter.factory.createCodeSnippetExpression("null").compile(), BinaryOperatorKind.NE);

			precodition.setCondition(ifcondition);
			precodition.setThenStatement((CtStatement) modificationPoint.getCodeElement().clone());

			OperatorInstance operatorInstance = new StatementOperatorInstance(modificationPoint, this, precodition);

			instances.add(operatorInstance);
		}
	}
	return instances;

}
 

@SuppressWarnings({ "rawtypes", "unchecked" })
@Override
public List<OperatorInstance> createOperatorInstances(ModificationPoint modificationPoint) {
	List<OperatorInstance> instances = new ArrayList<>();

	CtInvocation invocation = (CtInvocation) modificationPoint.getCodeElement();

	CtExpression targetExpresionOfMI = invocation.getTarget();

	if (targetExpresionOfMI instanceof CtVariableAccess) {

		CtStatement parentStatement = modificationPoint.getCodeElement().getParent(CtStatement.class);

		CtExpression ifcondition = MutationSupporter.factory.createBinaryOperator(targetExpresionOfMI,
				MutationSupporter.factory.createCodeSnippetExpression("null").compile(), BinaryOperatorKind.NE);

		CtIf precodition = MutationSupporter.factory.createIf();
		precodition.setCondition(ifcondition);
		precodition.setThenStatement(parentStatement);

		OperatorInstance operatorInstance = new StatementOperatorInstance(modificationPoint, this, parentStatement,
				precodition);

		instances.add(operatorInstance);
	}
	return instances;

}