feat(annot): Reference to an annotation field as an invocation. (#660)

src/main/java/spoon/support/reflect/declaration/CtAnnotationTypeImpl.java

@@ -16,7 +16,10 @@
  */
 package spoon.support.reflect.declaration;
 
+import spoon.reflect.code.CtComment;
+import spoon.reflect.declaration.CtAnnotation;
 import spoon.reflect.declaration.CtAnnotationType;
+import spoon.reflect.declaration.CtField;
 import spoon.reflect.declaration.CtFormalTypeDeclarer;
 import spoon.reflect.declaration.CtMethod;
 import spoon.reflect.declaration.CtType;
@@ -30,6 +33,7 @@
 import java.util.Collections;
 import java.util.List;
 import java.util.Set;
+import java.util.TreeSet;
 
 /**
  * The implementation for {@link spoon.reflect.declaration.CtAnnotationType}.
@@ -44,6 +48,62 @@ public void accept(CtVisitor v) {
  v.visitCtAnnotationType(this);
  }
 
+ private <R> CtMethod<R> createGhostMethod(CtField<R> field) {
+ final CtMethod<R> method = factory.Core().createMethod();
+ method.setImplicit(true);
+ method.setSimpleName(field.getSimpleName());
+ method.setModifiers(field.getModifiers());
+ method.setType(factory.Core().clone(field.getType()));
+ for (CtAnnotation<? extends Annotation> ctAnnotation : field.getAnnotations()) {
+ method.addAnnotation(factory.Core().clone(ctAnnotation));
+ }
+ for (CtComment ctComment : field.getComments()) {
+ method.addComment(factory.Core().clone(ctComment));
+ }
+ method.setDocComment(field.getDocComment());
+ method.setPosition(field.getPosition());
+ method.setShadow(field.isShadow());
+ return method;
+ }
+
+ private <R> void addGhostMethod(CtField<R> field) {
+ super.addMethod(createGhostMethod(field));
+ }
+
+ @Override
+ public <F, C extends CtType<T>> C addField(CtField<F> field) {
+ addGhostMethod(field);
+ return super.addField(field);
+ }
+
+ @Override
+ public <F, C extends CtType<T>> C addField(int index, CtField<F> field) {
+ addGhostMethod(field);
+ return super.addField(index, field);
+ }
+
+ @Override
+ public <F, C extends CtType<T>> C addFieldAtTop(CtField<F> field) {
+ addGhostMethod(field);
+ return super.addFieldAtTop(field);
+ }
+
+ @Override
+ public <C extends CtType<T>> C setFields(List<CtField<?>> fields) {
+ Set<CtMethod<?>> methods = new TreeSet<CtMethod<?>>();
+ for (CtField<?> field : fields) {
+ methods.add(createGhostMethod(field));
+ }
+ super.setMethods(methods);
+ return super.setFields(fields);
+ }
+
+ @Override
+ public <F> boolean removeField(CtField<F> field) {
+ super.removeMethod(createGhostMethod(field));
+ return super.removeField(field);
+ }
+
  @Override
  public Set<CtTypeReference<?>> getSuperInterfaces() {
  return Collections.emptySet();

src/main/java/spoon/support/visitor/SignaturePrinter.java

@@ -126,7 +126,9 @@ public <T> void visitCtMethod(CtMethod<T> m) {
  }
  write("> ");
  }
- write(m.getType().getQualifiedName());
+ if (m.getType() != null) {
+ write(m.getType().getQualifiedName());
+ }
  write(" ");
  write(m.getSimpleName());
  write("(");

src/test/java/spoon/test/annotation/AnnotationTest.java

@@ -318,7 +318,7 @@ public void testAnnotatedElementTypes() throws Exception {
  CtAnnotationType<?> annotationType = pkg.getType("Bound");
  assertEquals(Bound.class, annotationType.getActualClass());
  assertNull(annotationType.getSuperclass());
- assertEquals(0,annotationType.getAllMethods().size());
+ assertEquals(annotationType.getFields().size(),annotationType.getAllMethods().size());
  assertEquals(0,annotationType.getSuperInterfaces().size());
 
  annotations = annotationType.getAnnotations();

src/test/java/spoon/test/main/MainTest.java

@@ -112,7 +112,7 @@ public <T> void visitCtTypeReference(CtTypeReference<T> reference) {
  @Override
  public <T> void visitCtExecutableReference(CtExecutableReference<T> reference) {
  assertNotNull(reference);
- if (isLanguageExecutable(reference) || isDeclaredInAnAnnotation(reference)) {
+ if (isLanguageExecutable(reference)) {
  super.visitCtExecutableReference(reference);
  return;
  }

src/test/java/spoon/test/reference/AnnotationFieldReferenceTest.java

@@ -0,0 +1,30 @@
+package spoon.test.reference;
+
+import org.junit.Test;
+import spoon.reflect.code.CtInvocation;
+import spoon.reflect.declaration.CtExecutable;
+import spoon.reflect.declaration.CtField;
+import spoon.reflect.declaration.CtMethod;
+import spoon.reflect.factory.Factory;
+import spoon.reflect.visitor.filter.TypeFilter;
+import spoon.test.reference.testclasses.Mole;
+import spoon.test.reference.testclasses.Parameter;
+import spoon.testing.utils.ModelUtils;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNotNull;
+
+public class AnnotationFieldReferenceTest {
+ @Test
+ public void testAnnotationFieldReference() throws Exception {
+ final Factory factory = ModelUtils.build(Parameter.class, Mole.class);
+ final CtMethod<Object> make = factory.Class().get(Mole.class).getMethod("make", factory.Type().createReference(Parameter.class));
+ final CtInvocation<?> annotationInv = make.getElements(new TypeFilter<CtInvocation<?>>(CtInvocation.class)).get(0);
+ final CtExecutable<?> executableDeclaration = annotationInv.getExecutable().getExecutableDeclaration();
+ assertNotNull(executableDeclaration);
+ final CtField<?> value = factory.Annotation().get(Parameter.class).getField("value");
+ assertNotNull(value);
+ assertEquals(value.getSimpleName(), executableDeclaration.getSimpleName());
+ assertEquals(value.getType(), executableDeclaration.getType());
+ }
+}

src/test/java/spoon/test/reference/testclasses/Mole.java

@@ -0,0 +1,7 @@
+package spoon.test.reference.testclasses;
+
+public class Mole {
+ private void make(Parameter p) {
+ p.value();
+ }
+}

src/test/java/spoon/test/reference/testclasses/Parameter.java

@@ -0,0 +1,5 @@
+package spoon.test.reference.testclasses;
+
+public @interface Parameter {
+ String value();
+}