Merge pull request #530 from GerardPaligot/fix_529

src/main/java/spoon/reflect/declaration/CtType.java

@@ -32,6 +32,10 @@ public interface CtType<T> extends CtNamedElement, CtTypeInformation, CtTypeMemb
  * The string separator in a Java innertype qualified name.
  */
  String INNERTTYPE_SEPARATOR = "$";
+ /**
+ * Used in no classpath when we don't have any information to build the name of the type.
+ */
+ String NAME_UNKNOWN = "<unknown>";
 
  /**
  * Returns the simple (unqualified) name of this element.

src/main/java/spoon/support/compiler/jdt/JDTTreeBuilder.java

@@ -2558,7 +2558,7 @@ public boolean visit(MarkerAnnotation annotation, BlockScope scope) {
 
  private <A extends java.lang.annotation.Annotation> boolean visitMarkerAnnoation(MarkerAnnotation annotation, BlockScope scope) {
  CtAnnotation<A> a = factory.Core().createAnnotation();
- CtTypeReference<A> t = references.getTypeReference(annotation.resolvedType);
+ CtTypeReference<A> t = references.getTypeReference(annotation.resolvedType, annotation.type);
  a.setAnnotationType(t);
  context.enter(a, annotation);
  skipTypeInAnnotation = true;
@@ -2738,7 +2738,7 @@ public boolean visit(MethodDeclaration methodDeclaration, ClassScope scope) {
  }
 
  private boolean isContainsInTypeAnnotation(TypeBinding binding, Annotation a) {
- return !binding.hasTypeAnnotations() || !containsInTypeAnnotation(a, binding.getTypeAnnotations());
+ return binding == null || !binding.hasTypeAnnotations() || !containsInTypeAnnotation(a, binding.getTypeAnnotations());
  }
 
  private boolean containsInTypeAnnotation(Annotation a, AnnotationBinding[] typeAnnotations) {
@@ -3379,6 +3379,7 @@ public boolean visit(TypeDeclaration localTypeDeclaration, BlockScope scope) {
  if (localTypeDeclaration.binding == null) {
  // no classpath mode but JDT returns nothing. We create an empty class.
  t = factory.Core().createClass();
+ t.setSimpleName(CtType.NAME_UNKNOWN);
  ((CtClass) t).setSuperclass(references.getTypeReference(null, localTypeDeclaration.allocation.type));
  } else {
  t = createType(localTypeDeclaration);

src/test/java/spoon/test/constructorcallnewclass/NewClassTest.java

@@ -6,6 +6,7 @@
 import spoon.reflect.code.CtExpression;
 import spoon.reflect.code.CtNewClass;
 import spoon.reflect.declaration.CtClass;
+import spoon.reflect.declaration.CtType;
 import spoon.reflect.factory.Factory;
 import spoon.reflect.reference.CtExecutableReference;
 import spoon.reflect.reference.CtTypeReference;
@@ -161,7 +162,7 @@ public void testCtNewClassInNoClasspath() throws Exception {
  assertEquals("Lock$With", anonymousClass.getSuperclass().getQualifiedName());
  assertEquals("Lock", anonymousClass.getSuperclass().getDeclaringType().getSimpleName());
  assertEquals("Lock.With", anonymousClass.getSuperclass().toString());
- assertNull(anonymousClass.getSimpleName()); // In noclasspath, we don't have this information.
+ assertEquals(CtType.NAME_UNKNOWN, anonymousClass.getSimpleName()); // In noclasspath, we don't have this information.
  assertEquals(1, anonymousClass.getMethods().size());
 
  canBeBuilt("./target/new-class", 8, true);

src/test/java/spoon/test/reference/TypeReferenceTest.java

@@ -7,6 +7,7 @@
 import spoon.compiler.SpoonResourceHelper;
 import spoon.reflect.code.CtFieldRead;
 import spoon.reflect.code.CtInvocation;
+import spoon.reflect.code.CtNewClass;
 import spoon.reflect.declaration.CtClass;
 import spoon.reflect.declaration.CtField;
 import spoon.reflect.declaration.CtInterface;
@@ -392,6 +393,40 @@ public void testInvocationWithFieldAccessInNoClasspath() throws Exception {
  canBeBuilt("./src/test/resources/noclasspath/TestBot.java", 8, true);
  }
 
+ @Test
+ public void testAnnotationOnMethodWithPrimitiveReturnTypeInNoClasspath() throws Exception {
+ // contract: In no classpath mode, if we have an annotation declared on a method and overridden
+ // from a super class in an anonymous class, we should rewrite correctly the annotation and don't
+ // throw a NPE.
+ final Launcher launcher = new Launcher();
+ launcher.addInputResource("./src/test/resources/noclasspath/A.java");
+ launcher.setSourceOutputDirectory("./target/class-declaration");
+ launcher.getEnvironment().setNoClasspath(true);
+ launcher.run();
+
+ final CtClass<Object> aClass = launcher.getFactory().Class().get("A");
+ final CtClass anonymousClass = aClass.getElements(new TypeFilter<>(CtNewClass.class)).get(0).getAnonymousClass();
+ final CtMethod run = anonymousClass.getMethod("run");
+ assertNotNull(run);
+ assertEquals(1, run.getAnnotations().size());
+ assertEquals("@Override" + System.lineSeparator(), run.getAnnotations().get(0).toString());
+ }
+
+ @Test
+ public void testAnonymousClassesHaveAnEmptyStringForItsNameInNoClasspath() throws Exception {
+ // contract: In no classpath mode, a type reference have an empty string for its name.
+ final Launcher launcher = new Launcher();
+ launcher.addInputResource("./src/test/resources/noclasspath/A.java");
+ launcher.setSourceOutputDirectory("./target/class-declaration");
+ launcher.getEnvironment().setNoClasspath(true);
+ launcher.run();
+
+ final CtClass<Object> aClass = launcher.getFactory().Class().get("A");
+ final CtClass anonymousClass = aClass.getElements(new TypeFilter<>(CtNewClass.class)).get(0).getAnonymousClass();
+ assertEquals(CtType.NAME_UNKNOWN, anonymousClass.getReference().getSimpleName());
+ assertEquals(7, aClass.getReferencedTypes().size());
+ }
+
  class A {
  class Tacos<K> {
  }

src/test/resources/noclasspath/A.java

@@ -0,0 +1,18 @@
+import example.B;
+
+class A extends B {
+
+ private Runnable runnable;
+
+ public void foo() {
+ synchronized (lock) {
+ runnable = new Runnable() {
+
+ @Override
+ public void run() {
+
+ }
+ };
+ }
+ }
+}