fix(VariableAccessFilter): ensure all accesses are returned for generic fields

src/main/java/spoon/reflect/visitor/filter/VariableAccessFilter.java

@@ -8,20 +8,21 @@
 package spoon.reflect.visitor.filter;
 
 import spoon.reflect.code.CtVariableAccess;
+import spoon.reflect.declaration.CtVariable;
 import spoon.reflect.reference.CtVariableReference;
 import spoon.reflect.visitor.Filter;
 
 /**
- * This simple filter matches all the accesses to a given field.
+ * This simple filter matches all the accesses to a given variable.
  */
 public class VariableAccessFilter<T extends CtVariableAccess<?>> implements Filter<T> {
- CtVariableReference<?> variable;
+ private final CtVariableReference<?> variable;
+ private CtVariable<?> variableDeclaration;
 
  /**
- * Creates a new field access filter.
+ * Creates a new variable access filter.
  *
- * @param variable
- * the accessed variable
+ * @param variable the variable to find accesses for, must not be {@code null}
  */
  public VariableAccessFilter(CtVariableReference<?> variable) {
  if (variable == null) {
@@ -32,7 +33,22 @@ public VariableAccessFilter(CtVariableReference<?> variable) {
 
  @Override
  public boolean matches(T variableAccess) {
- return variable.equals(variableAccess.getVariable());
+ if (this.variable.equals(variableAccess.getVariable())) {
+ return true;
+ }
+ // If this.variable is a reference to a generic field, then the references might not be equal:
+ //
+ // Given `class A<T> { T t; }`, the reference would be to `T t`, but an access to `t` could look
+ // like this:
+ // `A<String> a = new A<>(); a.t = "foo";`
+ // ^^^ reference to `String t`
+ // As (String t) != (T t), the references are not equal, even though the same variable is accessed.
+ // Therefore, we fall back to comparing the declaration if the references were different.
+ if (this.variableDeclaration == null) {
+ this.variableDeclaration = this.variable.getDeclaration();
+ }
+
+ return this.variableDeclaration.equals(variableAccess.getVariable().getDeclaration());
  }
 
 }

src/test/java/spoon/test/filters/FilterTest.java

@@ -32,6 +32,7 @@
 import spoon.reflect.code.CtNewClass;
 import spoon.reflect.code.CtStatement;
 import spoon.reflect.code.CtSwitch;
+import spoon.reflect.code.CtVariableAccess;
 import spoon.reflect.declaration.CtClass;
 import spoon.reflect.declaration.CtElement;
 import spoon.reflect.declaration.CtExecutable;
@@ -75,6 +76,7 @@
 import spoon.reflect.visitor.filter.ReturnOrThrowFilter;
 import spoon.reflect.visitor.filter.SubtypeFilter;
 import spoon.reflect.visitor.filter.TypeFilter;
+import spoon.reflect.visitor.filter.VariableAccessFilter;
 import spoon.support.comparator.DeepRepresentationComparator;
 import spoon.support.reflect.declaration.CtMethodImpl;
 import spoon.support.visitor.SubInheritanceHierarchyResolver;
@@ -1430,4 +1432,27 @@ public boolean matches(CtElement element) {
 
  }
 
+ @Test
+ public void testVariableAccessFilterWithGenericField() {
+ // contract: VariableAccessFilter returns all accesses to a given field, even if it is generic
+ CtClass<?> ctClass = Launcher.parseClass(
+ "public class Example<T> {\n" +
+ " T field;\n" +
+ "\n" +
+ " public static void main(String[] args) {\n" +
+ " Example<String> example = new Example<>();\n" +
+ "\n" +
+ " example.field = \"Hello\"; // write access to Example#field\n" +
+ " System.out.println(example.field); // read access to Example#field\n" +
+ " }\n" +
+ "}\n"
+ );
+
+ List<CtVariableAccess<?>> accesses = ctClass.getElements(
+ new VariableAccessFilter<>(ctClass.getField("field").getReference())
+ );
+
+ assertEquals(2, accesses.size());
+ }
+
 }