use of spoon.reflect.reference.CtVariableReference in project spoon by INRIA.
the class CloneReferenceTest method testGetDeclarationAfterClone.
@Test
public void testGetDeclarationAfterClone() throws Exception {
// contract: all variable references of the clone (but fields) should point to the variable of the clone
Launcher spoon = new Launcher();
List<String> names = Arrays.asList("f1", "f2", "a", "b", "x", "param", "e");
spoon.addInputResource("./src/test/resources/noclasspath/A2.java");
spoon.getEnvironment().setComplianceLevel(8);
spoon.getEnvironment().setNoClasspath(true);
spoon.buildModel();
final CtClass<Object> a = spoon.getFactory().Class().get("A2");
// test before clone
for (String name : names) {
CtVariable var1 = findVariable(a, name);
CtVariable var2 = findReference(a, name).getDeclaration();
assertTrue(var1 == var2);
}
CtClass b = a.clone();
// test after clone
for (String name : names) {
CtVariable var1 = findVariable(b, name);
CtVariableReference refVar1 = findReference(b, name);
CtVariable var2 = refVar1.getDeclaration();
assertTrue("Var1 and var2 are not the same element", var1 == var2);
}
}
use of spoon.reflect.reference.CtVariableReference in project spoon by INRIA.
the class CloneReferenceTest method testGetDeclarationOfFieldAfterClone.
@Test
public void testGetDeclarationOfFieldAfterClone() throws Exception {
// contract: all field references of the clone point to the old class
// behaviour changed on https://github.com/INRIA/spoon/pull/1215
Launcher spoon = new Launcher();
String name = "field";
spoon.addInputResource("./src/test/resources/noclasspath/A2.java");
spoon.getEnvironment().setComplianceLevel(8);
spoon.getEnvironment().setNoClasspath(true);
spoon.buildModel();
final CtClass<Object> a = spoon.getFactory().Class().get("A2");
// test before clone
CtField oldVar1 = (CtField) findVariable(a, name);
CtField oldVar2 = (CtField) findReference(a, name).getDeclaration();
assertTrue(oldVar1 == oldVar2);
CtClass b = a.clone();
// test after clone
CtField var1 = (CtField) findVariable(b, name);
CtVariableReference refVar1 = findReference(b, name);
CtField var2 = (CtField) refVar1.getDeclaration();
assertTrue(var1 != var2);
assertTrue(var2 == oldVar1);
assertTrue(var1.getParent(CtClass.class) == b);
}
use of spoon.reflect.reference.CtVariableReference in project dspot by STAMP-project.
the class GeneralMinimizer method removeUselessDuplicateAssertions.
private void removeUselessDuplicateAssertions(CtMethod<?> amplifiedTestToBeMinimized, CtInvocation<?> duplicatesAssertion, List<CtStatement> statements) {
final CtVariableReference variable = ((CtVariableRead<?>) duplicatesAssertion.filterChildren(new TypeFilter<CtVariableRead<?>>(CtVariableRead.class)).first()).getVariable();
boolean canBeRemoved = true;
for (int i = statements.indexOf(duplicatesAssertion) + 1; i < statements.lastIndexOf(duplicatesAssertion); i++) {
if (!AmplificationChecker.isAssert(statements.get(i))) {
final CtVariableRead<?> first = (CtVariableRead<?>) statements.get(i).filterChildren(new TypeFilter<CtVariableRead<?>>(CtVariableRead.class) {
@Override
public boolean matches(CtVariableRead<?> element) {
return element.getVariable().equals(variable);
}
}).first();
if (first != null) {
canBeRemoved = false;
break;
}
}
}
if (canBeRemoved) {
amplifiedTestToBeMinimized.getBody().getStatements().remove(statements.lastIndexOf(duplicatesAssertion));
}
}
use of spoon.reflect.reference.CtVariableReference in project spoon by INRIA.
the class CtRenameLocalVariableRefactoring method detectNameConflicts.
@Override
protected void detectNameConflicts() {
/*
* There can be these conflicts
* 1) target variable would shadow before declared variable (parameter, localVariable, catchVariable)
* --------------------------------------------------------------------------------------------------
*/
PotentialVariableDeclarationFunction potentialDeclarationFnc = new PotentialVariableDeclarationFunction(newName);
CtVariable<?> var = getTarget().map(potentialDeclarationFnc).first();
if (var != null) {
if (var instanceof CtField) {
/*
* we have found a field of same name.
* It is not problem, because variables can hide field declaration.
* Do nothing - OK
*/
} else if (potentialDeclarationFnc.isTypeOnTheWay()) {
/*
* There is a local class declaration between future variable reference and variable declaration `var`.
* The found variable declaration `var` can be hidden by target variable with newName
* as long as there is no reference to `var` in visibility scope of the target variable.
* So search for such `var` reference now
*/
CtVariableReference<?> shadowedVar = target.map(new SiblingsFunction().includingSelf(true).mode(Mode.NEXT)).map(new VariableReferenceFunction(var)).first();
if (shadowedVar != null) {
// found variable reference, which would be shadowed by variable after rename.
createNameConflictIssue(var, shadowedVar);
} else {
/*
* there is no local variable reference, which would be shadowed by variable after rename.
* OK
*/
}
} else {
/*
* the found variable is in conflict with target variable with newName
*/
createNameConflictIssue(var);
}
}
/*
* 2) target variable is shadowed by later declared variable
* ---------------------------------------------------------
*/
final QueryDriver queryDriver = new QueryDriver();
getTarget().map(new LocalVariableScopeFunction(queryDriver)).select(new Filter<CtElement>() {
/**
* return true for all CtVariables, which are in conflict
*/
@Override
public boolean matches(CtElement element) {
if (element instanceof CtType<?>) {
CtType<?> localClass = (CtType<?>) element;
// TODO use faster hasField, implemented using map(new AllFieldsFunction()).select(new NameFilter(newName)).first()!=null
Collection<CtFieldReference<?>> fields = localClass.getAllFields();
for (CtFieldReference<?> fieldRef : fields) {
if (newName.equals(fieldRef.getSimpleName())) {
/*
* we have found a local class field, which will shadow input local variable if it's reference is in visibility scope of that field.
* Search for target variable reference in visibility scope of this field.
* If found than we cannot rename target variable to newName, because that reference would be shadowed
*/
queryDriver.ignoreChildrenOf(element);
CtLocalVariableReference<?> shadowedVar = element.map(new LocalVariableReferenceFunction(target)).first();
if (shadowedVar != null) {
createNameConflictIssue(fieldRef.getFieldDeclaration(), shadowedVar);
return true;
}
return false;
}
}
return false;
}
if (element instanceof CtVariable<?>) {
CtVariable<?> variable = (CtVariable<?>) element;
if (newName.equals(variable.getSimpleName()) == false) {
// the variable with different name. Ignore it
return false;
}
// we have found a variable with new name
if (variable instanceof CtField) {
throw new SpoonException("This should not happen. The children of local class which contains a field with new name should be skipped!");
}
if (variable instanceof CtCatchVariable || variable instanceof CtLocalVariable || variable instanceof CtParameter) {
/*
* we have found a catch variable or local variable or parameter with new name.
*/
if (queryDriver.isInContextOfLocalClass()) {
/*
* We are in context of local class.
* This variable would shadow input local variable after rename
* so we cannot rename if there exist a local variable reference in variable visibility scope.
*/
queryDriver.ignoreChildrenOf(variable.getParent());
CtQueryable searchScope;
if (variable instanceof CtLocalVariable) {
searchScope = variable.map(new SiblingsFunction().includingSelf(true).mode(Mode.NEXT));
} else {
searchScope = variable.getParent();
}
CtLocalVariableReference<?> shadowedVar = searchScope.map(new LocalVariableReferenceFunction(target)).first();
if (shadowedVar != null) {
// found local variable reference, which would be shadowed by variable after rename.
createNameConflictIssue(variable, shadowedVar);
return true;
}
// there is no local variable reference, which would be shadowed by variable after rename.
return false;
} else {
/*
* We are not in context of local class.
* So this variable is in conflict. Return it
*/
createNameConflictIssue(variable);
return true;
}
} else {
// Any new variable type???
throw new SpoonException("Unexpected variable " + variable.getClass().getName());
}
}
return false;
}
}).first();
}
use of spoon.reflect.reference.CtVariableReference in project spoon by INRIA.
the class VariableAccessTest method testDeclarationOfVariableReference.
@Test
public void testDeclarationOfVariableReference() throws Exception {
final Launcher launcher = new Launcher();
launcher.addInputResource("./src/test/resources/noclasspath/Foo2.java");
launcher.getEnvironment().setNoClasspath(true);
launcher.buildModel();
launcher.getModel().getElements(new TypeFilter<CtVariableReference>(CtVariableReference.class) {
@Override
public boolean matches(CtVariableReference element) {
try {
element.clone().getDeclaration();
} catch (NullPointerException e) {
fail("Fail with " + element.getSimpleName() + " declared in " + element.getParent().getShortRepresentation());
}
return super.matches(element);
}
});
}
Aggregations