Java CtVariableAccess类代码示例

import spoon.reflect.code.CtVariableAccess; //导入依赖的package包/类
@Override
public @NotNull String getText() {
	final String txt;
	if(exp instanceof CtInvocation<?> && ((CtInvocation<?>) exp).getTarget() instanceof CtVariableAccess<?>) {
		txt = ((CtVariableAccess<?>)((CtInvocation<?>) exp).getTarget()).getVariable().getSimpleName();
	}else {
		if(exp instanceof CtVariableAccess<?>) {
			txt = ((CtVariableAccess<?>)exp).getVariable().getSimpleName();
		}else {
			if(exp instanceof CtLambda<?>) {
				final CtLambda<?> lambda = (CtLambda<?>) exp;
				txt = lambda.getExpression().getElements((CtInvocation<?> invok) -> TestFXProcessor.isRobotInvocation(invok)).stream().
					map(invok -> invok.getExecutable().getSimpleName()).collect(Collectors.joining());
			}else {
				txt = exp.toString();
			}
		}
	}

	return txt.replaceAll("[^A-Za-z0-9]", "") + getIDCmd();
}
 

import spoon.reflect.code.CtVariableAccess; //导入依赖的package包/类
@Override
public boolean equals(final @Nullable Object o) {
	if(this == o) return true;
	if(!(o instanceof Cmd)) return false;

	Cmd<?> cmd = (Cmd<?>) o;

	if(exp instanceof CtVariableAccess<?> && cmd.exp instanceof CtVariableAccess<?>) {
		return ((CtVariableAccess<?>) exp).getVariable().getDeclaration() == ((CtVariableAccess<?>) cmd.exp).getVariable().getDeclaration();
	}

	if(exp instanceof CtInvocation<?> && cmd.exp instanceof CtInvocation<?>) {
		final CtInvocation<?> invok1 = (CtInvocation<?>) exp;
		final CtInvocation<?> invok2 = (CtInvocation<?>) cmd.exp;
		if(invok1.getTarget() instanceof CtVariableAccess<?> && invok2.getTarget() instanceof CtVariableAccess<?>) {
			return ((CtVariableAccess<?>) invok1.getTarget()).getVariable().getDeclaration() == ((CtVariableAccess<?>) invok1.getTarget()).getVariable().getDeclaration();
		}
	}

	return exp.equals(cmd.exp);
}
 

import spoon.reflect.code.CtVariableAccess; //导入依赖的package包/类
public static List<CtVariableAccess> checkMapping(Map<CtVariableAccess, List<CtVariable>> matched) {
	List<CtVariableAccess> notMapped = new ArrayList<>();

	if (matched == null)
		return notMapped;

	// Now, we analyze if all access were matched
	for (CtVariableAccess ctVariableAccess : matched.keySet()) {
		List<CtVariable> mapped = matched.get(ctVariableAccess);
		if (mapped.isEmpty()) {
			// One var access was not mapped
			// return false;
			notMapped.add(ctVariableAccess);
		}
	}
	// All VarAccess were mapped
	// return true;
	return notMapped;
}
 

import spoon.reflect.code.CtVariableAccess; //导入依赖的package包/类
/**
 * Returns a map between the variables with name conflicts.
 * 
 * @param varsFromContext
 * @param varInductionCollected
 * @return
 */
public static Map<CtVariableAccess, List<CtVariable>> searchVarNameConflicts(List<CtVariable> varsFromContext,
		List<CtVariableAccess> varInductionCollected) {

	Map<CtVariableAccess, List<CtVariable>> mappingConflicts = new HashMap<>();

	for (CtVariableAccess inductionVar : varInductionCollected) {

		List<CtVariable> varsConf = new ArrayList<>();
		String nameInduction = inductionVar.getVariable().getSimpleName();

		for (CtVariable ctVariableContext : varsFromContext) {
			String nameVarContexr = ctVariableContext.getSimpleName();
			if (nameInduction.equals(nameVarContexr)) {
				varsConf.add(ctVariableContext);
			}
		}
		if (varsConf.size() > 0) {
			mappingConflicts.put(inductionVar, varsConf);
		}

	}
	return mappingConflicts;
}
 

import spoon.reflect.code.CtVariableAccess; //导入依赖的package包/类
/**
 * It retrieves all variables access which declarations are inside the
 * ingredient.
 * 
 * @param ingredientRootElement
 * @param varAccessCollected
 * @return
 */
public static List<CtVariableAccess> collectInductionVariableAccess(CtElement ingredientRootElement,
		List<CtVariableAccess> varAccessCollected) {

	List<CtVariableAccess> induction = new ArrayList<>();

	for (CtVariableAccess ctVariableAccess : varAccessCollected) {

		CtVariableReference varref = ctVariableAccess.getVariable();

		// We are interesting in induction vars, they are modeled as
		// LocalVariables
		if (!(varref instanceof CtLocalVariableReference))
			continue;

		CtVariable var = varref.getDeclaration();

		boolean insideIngredient = checkParent(var, ingredientRootElement);
		if (insideIngredient)
			induction.add(ctVariableAccess);

	}
	return induction;
}
 

import spoon.reflect.code.CtVariableAccess; //导入依赖的package包/类
private List<CtTypeReference<?>> getDeepDef2(CtExpression<?> condition) {
	List<CtTypeReference<?>> res = new ArrayList<>();

	List<CtVariableAccess<?>> vars = defuse.findUsedVar(condition);
	for (CtVariableAccess<?> var : vars) {
		// if (var.getVariable() instanceof CtFieldReference){//conds such
		// as KeyEvent.VK_ESCAPE, where getDeepDef(var) does not found the
		// var declaration
		// CtFieldReference fieldRef = (CtFieldReference)
		// var.getVariable();//FIXME
		// CtTypeReference fieldType = fieldRef.getDeclaringType();
		// res.add(fieldType);
		// }
		// if (var.getVariable() instanceof CtVariable){
		// CtVariable variable = (CtVariable) var.getVariable();
		// res.add(var.getType());//maybe i cannot
		//
		// }
		// else
		if (var.getVariable() instanceof CtParameterReference) {
			CtParameterReference<?> param = (CtParameterReference<?>) var.getVariable();
			res.add(param.getType());
		} else {
			Set<CtExpression<?>> defs = getVarDefs(var);
			for (CtExpression<?> def : defs) {
				res.addAll(getDeepDef2(def));
			}
		}
	}
	return res;
}
 

import spoon.reflect.code.CtVariableAccess; //导入依赖的package包/类
private Set<CtExpression<?>> getVarDefs(CtVariableAccess<?> var) {
	Set<CtExpression<?>> res = new HashSet<>();

	Set<CtCodeElement> defs = defuse.getReachingDef(var);
	CtVariable<?> dec = var.getVariable().getDeclaration();
	if (defs != null) {
		for (CtCodeElement def : defs) {
			res.addAll(processLine(def));
		}
	} else if (dec != null && dec.getDefaultExpression() != null) {
		res.add(dec.getDefaultExpression());
	}

	return res;
}
 

import spoon.reflect.code.CtVariableAccess; //导入依赖的package包/类
/**
 * Find variables in the expression, find their last definitions and store
 * these pairs
 */
private void storeUseDef(CtExpression<?> expr, Map<CtVariable<?>, Set<CtCodeElement>> definitions) {
	List<CtVariableAccess<?>> varAccess = findUsedVar(expr);
	if (!varAccess.isEmpty()) {
		usedVar.put(expr, varAccess);
	}
	for (CtVariableAccess<?> var : varAccess) {
		CtVariable<?> decl = var.getVariable().getDeclaration();
		reachingDef.put(var, definitions.get(decl)); // store (use,def)
	}
}
 

import spoon.reflect.code.CtVariableAccess; //导入依赖的package包/类
/**
 * Find variables access in the expression, and add new definitions
 */
private void updateUseDef(CtExpression<?> expr, Map<CtVariable<?>, Set<CtCodeElement>> definitions) {
	List<CtVariableAccess<?>> varAccess = findUsedVar(expr);
	for (CtVariableAccess<?> var : varAccess) {
		CtVariable<?> decl = var.getVariable().getDeclaration();

		Set<CtCodeElement> oldDef = reachingDef.get(var);
		if (oldDef != null) {
			Set<CtCodeElement> newDef = definitions.get(decl);
			if (newDef != null)
				oldDef.addAll(newDef);
		}
	}
}
 

import spoon.reflect.code.CtVariableAccess; //导入依赖的package包/类
/**
 * Get used variables in this expression. If the expression is a method
 * call, the caller is included in used variables
 */
public List<CtVariableAccess<?>> findUsedVar(CtExpression<?> expr) {
	List<CtVariableAccess<?>> res = new ArrayList<>();

	if (expr instanceof CtFieldAccess) {
		CtFieldAccess<?> access = (CtFieldAccess<?>) expr;
		if (access.getTarget() != null) {
			res.addAll(findUsedVar(access.getTarget()));
		} else {
			res.add(access);
		}
	} else if (expr instanceof CtBinaryOperator) {
		CtBinaryOperator<?> op = (CtBinaryOperator<?>) expr;
		res.addAll(findUsedVar(op.getLeftHandOperand()));
		res.addAll(findUsedVar(op.getRightHandOperand()));
	} else if (expr instanceof CtUnaryOperator) {// Added to get all
													// conditions of a
													// command in Command
													// class
		CtUnaryOperator<?> unary = (CtUnaryOperator<?>) expr;
		res.addAll(findUsedVar(unary.getOperand()));
	} else if (expr instanceof CtInvocation) {
		CtInvocation<?> invoke = (CtInvocation<?>) expr;
		res.addAll(findUsedVar(invoke.getTarget()));
		for (Object param : invoke.getArguments()) {
			res.addAll(findUsedVar((CtExpression<?>) param));
		}
	} else if (expr instanceof CtVariableAccess) {
		res.add((CtVariableAccess<?>) expr);
	}

	return res;
}
 

import spoon.reflect.code.CtVariableAccess; //导入依赖的package包/类
/**
 * Get attributes & methods parameters dependences for variable access in
 * this condition
 */
public Set<CtVariable<?>> getDeepDef(CtExpression<?> condition) {
	Set<CtVariable<?>> res = new HashSet<>();

	List<CtVariableAccess<?>> vars = findUsedVar(condition);
	for (CtVariableAccess<?> var : vars) {
		res.addAll(getDeepDef(var));
	}

	return res;
}
 

import spoon.reflect.code.CtVariableAccess; //导入依赖的package包/类
/**
 * Return statements that are not used by another.
 */
public Set<CtCodeElement> getAllTerminalStatements() {

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

	for (BasicBlock block : cfg.getAllNode()) {
		for (CtCodeElement line : block.getElements()) {

			// Add this line to candidates statements
			res.add(line);

			// Remove statements which are dependencies
			List<CtVariableAccess<?>> vars = getUsedVariables(line);
			if (vars != null && !vars.isEmpty()) {
				for (CtVariableAccess<?> var : vars) {
					Set<CtCodeElement> defs = reachingDef.get(var);
					if (defs != null) {
						for (CtCodeElement def : defs) {
							if (res.contains(def))
								res.remove(def);
						}
					}
				}
			}
		}
	}

	return res;
}
 

import spoon.reflect.code.CtVariableAccess; //导入依赖的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.CtVariableAccess; //导入依赖的package包/类
public List<CtVariableAccess<?>> extractUsagesOfVar(final @NotNull CtVariable<?> var) {
	CtElement parent;

	if(var instanceof CtLocalVariable<?>) {
		parent = var.getParent(CtBlock.class);
	}else {
		if(var.getVisibility() == null) {
			parent = var.getParent(CtPackage.class);
			if(parent == null) parent = var.getParent(CtClass.class);
		}else {
			switch(var.getVisibility()) {
				case PRIVATE:
					parent = var.getParent(CtClass.class);
					break;
				case PROTECTED:
					parent = var.getParent(CtPackage.class);
					if(parent == null) parent = var.getParent(CtClass.class);
					break;
				case PUBLIC:
					parent = var.getFactory().Package().getRootPackage();
					break;
				default:
					parent = null;
					break;
			}
		}
	}

	if(parent != null) {
		return parent.getElements(new MyVariableAccessFilter(var));
	}

	return Collections.emptyList();
}
 

import spoon.reflect.code.CtVariableAccess; //导入依赖的package包/类
@Override
public boolean matches(final CtVariableAccess<?> variableAccess) {
	final CtVariableReference<?> varAc = variableAccess.getVariable();

	try {
		return varAc != null && varAc.getDeclaration() == variable;
	}catch(NullPointerException ex) {
		return false;
	}
}