import spoon.reflect.code.CtAssignment; //导入依赖的package包/类
@Override
public void process(CtStatement ctStatement) {
    if (!(ctStatement instanceof CtLocalVariable<?>) && !(ctStatement instanceof CtAssignment<?, ?>))
        return;

    Class<?> localVariableClass = ((CtTypedElement<?>) ctStatement).getType().getActualClass();
    if (localVariableClass.equals(Integer.class) || localVariableClass.equals(int.class)) {
        if (ctStatement instanceof CtAssignment<?, ?>) {
            replaceInteger(((CtAssignment<?, ?>) ctStatement).getAssignment());
        } else {
            replaceInteger(((CtLocalVariable<?>) ctStatement).getDefaultExpression());
        }
    } else if (localVariableClass.equals(Double.class) || localVariableClass.equals(double.class)) {
        if (ctStatement instanceof CtAssignment<?, ?>) {
            replaceDouble(((CtAssignment<?, ?>) ctStatement).getAssignment());
        } else {
            replaceDouble(((CtLocalVariable<?>) ctStatement).getDefaultExpression());
        }
    } else if (localVariableClass.equals(Boolean.class) || localVariableClass.equals(boolean.class)) {
        if (ctStatement instanceof CtAssignment<?, ?>) {
            replaceBoolean(((CtAssignment<?, ?>) ctStatement).getAssignment());
        } else {
            replaceBoolean(((CtLocalVariable<?>) ctStatement).getDefaultExpression());
        }
    }
}
 

import spoon.reflect.code.CtAssignment; //导入依赖的package包/类
/**
 * Get all assigned fields in this block
 */
public Set<CtVariable<?>> getAssignedField(BasicBlock block) {
	Set<CtVariable<?>> res = new HashSet<>();

	for (CtCodeElement line : block.getElements()) {

		if (line instanceof CtAssignment) {
			// CtAssignment<?,?> assignment = (CtAssignment<?,?>) line;
			CtExpression<?> leftPart = ((CtAssignment<?, ?>) line).getAssigned();
			if (leftPart instanceof CtFieldAccess) {
				CtField<?> field = ((CtFieldAccess<?>) leftPart).getVariable().getDeclaration();
				res.add(field);
			}
		}

	}

	return res;
}
 

import spoon.reflect.code.CtAssignment; //导入依赖的package包/类
/**
 * Find field assignment statements
 */
private Set<CtCodeElement> findFieldSetters() { // TODO: refactor with
												// Defuse.getAssignedField()

	Set<CtCodeElement> res = new HashSet<>();

	for (BasicBlock block : cfg.getAllNode()) {
		for (CtCodeElement line : block.getElements()) {
			if (line instanceof CtAssignment) {
				CtAssignment<?, ?> assignment = (CtAssignment<?, ?>) line;
				if (assignment.getAssigned() instanceof CtFieldAccess) {
					res.add(line);
				}
			}
		}
	}

	return res;
}
 

import spoon.reflect.code.CtAssignment; //导入依赖的package包/类
@Override
public void process(CtStatement element) {

	if (element instanceof CtIf) {
		add(((CtIf) element).getCondition());
	} else if (element instanceof CtFor) {
		add(((CtFor) element).getExpression());
	} else if (element instanceof CtWhile) {
		add(((CtWhile) element).getLoopingExpression());
	} else if (element instanceof CtDo) {
		add(((CtDo) element).getLoopingExpression());
	} else if (element instanceof CtThrow) {
		add(((CtThrow) element).getThrownExpression());
	} else if (element instanceof CtInvocation && (element.getParent() instanceof CtBlock)) {
		add(element);
	} else if (element instanceof CtAssignment || element instanceof CtConstructorCall
			|| element instanceof CtCFlowBreak || element instanceof CtLocalVariable) {
		add(element);
	}

}
 

import spoon.reflect.code.CtAssignment; //导入依赖的package包/类
public LiteralReplacer(Class<?> cl, CtStatement statement, StatementType statementType) {
    super(statement, statementType);
    if (statement instanceof CtAssignment<?, ?>) {
        super.setDefaultValue(((CtAssignment<?, ?>) statement).getAssignment().toString());
    } else if (statement instanceof CtLocalVariable<?>) {
        super.setDefaultValue(((CtLocalVariable<?>) statement).getDefaultExpression().toString());
    }
    super.setType(cl);
}
 

import spoon.reflect.code.CtAssignment; //导入依赖的package包/类
/**
 * Must return true if the field is used in @action's conditionals and not
 * defined in the @action's method
 */
public boolean isControlledBy(Action action, CtAssignment<?, ?> fieldAssignment) {// TODO:
																					// move
																					// to
																					// Action

	CtField<?> field = null;
	CtExpression<?> leftPart = fieldAssignment.getAssigned();
	if (leftPart instanceof CtFieldAccess) {
		field = ((CtFieldAccess<?>) leftPart).getVariable().getDeclaration();
	}

	for (CtExpression<?> cond : action.getConditions()) {
		List<CtVariableAccess<?>> usedVars = defuse.findUsedVar(cond);
		for (CtVariableAccess<?> usedVar : usedVars) {

			// if(field != null && field ==
			// usedVar.getVariable().getDeclaration()){
			// Set<CtCodeElement> lastDef = defuse.getReachingDef(usedVar);
			// if(lastDef == null) return true;
			// }

			Set<CtVariable<?>> allDep = defuse.getDeepDef(usedVar);
			if (field != null && allDep.contains(field))
				return true;
		}
	}

	return false;
}
 

import spoon.reflect.code.CtAssignment; //导入依赖的package包/类
public static boolean elementUsesGUIParam(final CtElement elt, final List<CtParameterReference<?>> guiParams, final CtBlock<?> mainBlock,
										final Set<CtElement> alreadyVisited) {
		if(alreadyVisited.contains(elt)) {
			return false;
		}

		// Check whether a GUI parameter is directly used in the statement.
		//FIXME 5.5
//		if(guiParams.stream().anyMatch(param -> elt.getElements(new BasicFilter<>(CtParameterReference.class)).stream().noneMatch(ref -> ref.equals(param)))){
		if(guiParams.stream().anyMatch(param -> !elt.getReferences(new DirectReferenceFilter<>(param)).isEmpty())) {
			return true;
		}

		alreadyVisited.add(elt);

		// Otherwise, looking for local variables that use a GUI parameter.
		return elt.getElements(new LocalVariableAccessFilter()).stream().
			anyMatch(var ->
				// Maybe the declaration of the variable refers to a GUI parameter
				elementUsesGUIParam(var.getDeclaration(), guiParams, mainBlock, alreadyVisited) ||
					// or an assignment of this variable in the main block refers to a GUI parameter
					// 1. Looking for the assignments in the block
					mainBlock.getElements(new BasicFilter<>(CtAssignment.class)).stream().
						// 2. Keeping only the variable write
						anyMatch(assig -> assig.getAssigned() instanceof CtVariableWrite<?> &&
						// 3. Checking that the assigned variable is our current variable
						((CtVariableWrite<?>)assig.getAssigned()).getVariable().equals(var) &&
							// 4. Checking that the assignment directly or indirectly refers to GUI parameter
							elementUsesGUIParam(assig.getAssignment(), guiParams, mainBlock, alreadyVisited)));
	}
 

import spoon.reflect.code.CtAssignment; //导入依赖的package包/类
@Override
public Transformation query() throws QueryException {
    ASTDelete delete = new ASTDelete();
    CtAssignment stmt = affectations.remove(random.nextInt(affectations.size()));
    delete.setTransplantationPoint(new Statement(stmt));

    return delete;
}
 

import spoon.reflect.code.CtAssignment; //导入依赖的package包/类
@Override
public void process(CtExpression element) {

	if (element instanceof CtAssignment || element instanceof CtNewArray || element instanceof CtTypeAccess
			|| element instanceof CtVariableAccess || element instanceof CtLiteral)
		return;
	if (element.getType() != null)
		this.add(element);

}
 

import spoon.reflect.code.CtAssignment; //导入依赖的package包/类
public VariableAssignmentFilter(CtVariable<?> variable) {
    super(CtAssignment.class);
    this.variable = variable;
}
 

import spoon.reflect.code.CtAssignment; //导入依赖的package包/类
@Override
public boolean matches(CtAssignment<?, ?> element) {
    return element.getAssigned().getShortRepresentation().equals(variable().getShortRepresentation());
}
 

import spoon.reflect.code.CtAssignment; //导入依赖的package包/类
public static <T> CtAssignment<T, T> reassignDefault(CtField<T> field) {
    Factory f = field.getFactory();
    return f.Code().createVariableAssignment(
            field.getReference(), false, f.Core().clone(field.getDefaultExpression()));
}
 

import spoon.reflect.code.CtAssignment; //导入依赖的package包/类
public <T extends CtElement> boolean containsWriteLocalVarsOnly(@Nullable List<T> stats) {
	return stats != null && stats.parallelStream().allMatch(s ->
		SpoonHelper.INSTANCE.isReturnBreakStatement(s) ||
		s instanceof CtAssignment && ((CtAssignment<?, ?>) s).getAssigned() instanceof CtVariableWrite ||
		s instanceof CtUnaryOperator && ((CtUnaryOperator<?>) s).getOperand() instanceof CtVariableWrite);
}
 

import spoon.reflect.code.CtAssignment; //导入依赖的package包/类
public DeleteAffectationQuery(InputProgram inputProgram) {
    super(inputProgram);
    affectations = inputProgram.getAllElement(CtAssignment.class);
}
 

import spoon.reflect.code.CtAssignment; //导入依赖的package包/类
@Override
public <T, A extends T> void visitCtAssignment(CtAssignment<T, A> e) {
	label = "=";
}