Search in sources :

Example 1 with CtVariableReference

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);
    }
}
Also used : CtClass(spoon.reflect.declaration.CtClass) CtVariableReference(spoon.reflect.reference.CtVariableReference) CtVariable(spoon.reflect.declaration.CtVariable) Launcher(spoon.Launcher) Test(org.junit.Test)

Example 2 with CtVariableReference

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);
}
Also used : CtClass(spoon.reflect.declaration.CtClass) CtVariableReference(spoon.reflect.reference.CtVariableReference) CtField(spoon.reflect.declaration.CtField) Launcher(spoon.Launcher) Test(org.junit.Test)

Example 3 with CtVariableReference

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));
    }
}
Also used : CtVariableReference(spoon.reflect.reference.CtVariableReference) CtVariableRead(spoon.reflect.code.CtVariableRead)

Example 4 with CtVariableReference

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();
}
Also used : CtVariableReference(spoon.reflect.reference.CtVariableReference) SiblingsFunction(spoon.reflect.visitor.filter.SiblingsFunction) SpoonException(spoon.SpoonException) CtElement(spoon.reflect.declaration.CtElement) VariableReferenceFunction(spoon.reflect.visitor.filter.VariableReferenceFunction) LocalVariableReferenceFunction(spoon.reflect.visitor.filter.LocalVariableReferenceFunction) CtFieldReference(spoon.reflect.reference.CtFieldReference) CtParameter(spoon.reflect.declaration.CtParameter) CtLocalVariable(spoon.reflect.code.CtLocalVariable) CtType(spoon.reflect.declaration.CtType) Filter(spoon.reflect.visitor.Filter) CtField(spoon.reflect.declaration.CtField) CtQueryable(spoon.reflect.visitor.chain.CtQueryable) CtVariable(spoon.reflect.declaration.CtVariable) PotentialVariableDeclarationFunction(spoon.reflect.visitor.filter.PotentialVariableDeclarationFunction) CtCatchVariable(spoon.reflect.code.CtCatchVariable) LocalVariableScopeFunction(spoon.reflect.visitor.filter.LocalVariableScopeFunction) LocalVariableReferenceFunction(spoon.reflect.visitor.filter.LocalVariableReferenceFunction)

Example 5 with CtVariableReference

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);
        }
    });
}
Also used : CtVariableReference(spoon.reflect.reference.CtVariableReference) Launcher(spoon.Launcher) Test(org.junit.Test)

Aggregations

CtVariableReference (spoon.reflect.reference.CtVariableReference)6 Test (org.junit.Test)3 Launcher (spoon.Launcher)3 SpoonException (spoon.SpoonException)2 CtClass (spoon.reflect.declaration.CtClass)2 CtElement (spoon.reflect.declaration.CtElement)2 CtField (spoon.reflect.declaration.CtField)2 CtType (spoon.reflect.declaration.CtType)2 CtVariable (spoon.reflect.declaration.CtVariable)2 Filter (spoon.reflect.visitor.Filter)2 CtCatchVariable (spoon.reflect.code.CtCatchVariable)1 CtLocalVariable (spoon.reflect.code.CtLocalVariable)1 CtVariableRead (spoon.reflect.code.CtVariableRead)1 CtParameter (spoon.reflect.declaration.CtParameter)1 CtFieldReference (spoon.reflect.reference.CtFieldReference)1 CtQuery (spoon.reflect.visitor.chain.CtQuery)1 CtQueryable (spoon.reflect.visitor.chain.CtQueryable)1 LocalVariableReferenceFunction (spoon.reflect.visitor.filter.LocalVariableReferenceFunction)1 LocalVariableScopeFunction (spoon.reflect.visitor.filter.LocalVariableScopeFunction)1 PotentialVariableDeclarationFunction (spoon.reflect.visitor.filter.PotentialVariableDeclarationFunction)1