Merge pull request #500 from GerardPaligot/fix_type_generics

Author: monperrus

src/main/java/spoon/reflect/visitor/DefaultJavaPrettyPrinter.java

@@ -1507,7 +1507,10 @@ public <T> void visitCtMethod(CtMethod<T> m) {
 			write("default ");
 		}
 		writeFormalTypeParameters(m.getFormalTypeParameters());
+		final boolean old = context.ignoreGenerics;
+		context.ignoreGenerics = false;
 		scan(m.getType());
+		context.ignoreGenerics = old;
 		write(" ");
 		write(m.getSimpleName());
 		write("(");
@@ -1928,14 +1931,9 @@ public <T> void visitCtTypeReference(CtTypeReference<T> ref) {
 			write(ref.getSimpleName());
 		} else {
 			if (ref.getDeclaringType() != null) {
-				if (!context.currentThis.contains(ref.getDeclaringType()) || ref.getModifiers().contains(ModifierKind.STATIC) || hasDeclaringTypeWithGenerics(ref)) {
-					if (!context.ignoreEnclosingClass) {
-						boolean ign = context.ignoreGenerics;
-						context.ignoreGenerics = false;
-						scan(ref.getDeclaringType());
-						write(".");
-						context.ignoreGenerics = ign;
-					}
+				if (!context.ignoreEnclosingClass) {
+					scan(ref.getDeclaringType());
+					write(".");
 				}
 				write(ref.getSimpleName());
 			} else {
@@ -1957,34 +1955,6 @@ public <T> void visitCtImplicitTypeReference(CtImplicitTypeReference<T> referenc
 		// The type is implicit, we don't print it!
 	}
 
-	private <T> boolean hasDeclaringTypeWithGenerics(CtTypeReference<T> reference) {
-		// If current reference is a class declared in a method, we don't need this hack.
-		if (reference.getDeclaration() == null) {
-			return false;
-		}
-		if (reference.getDeclaration().getParent(CtMethod.class) != null) {
-			return false;
-		}
-		// If the declaring type isn't a CtType, we don't need this hack.
-		if (reference.getDeclaringType() == null) {
-			return false;
-		}
-		// If current reference use generic types, we don't need this hack.
-		if (reference.getActualTypeArguments().size() != 0
-				&& reference.getDeclaringType().getActualTypeArguments().size() == 0) {
-			return false;
-		}
-		final CtElement declaration = reference.getDeclaringType().getDeclaration();
-		if (declaration == null) {
-			return false;
-		}
-		if (!(declaration instanceof CtType)) {
-			return false;
-		}
-		// Checks if the declaring type has generic types.
-		return ((CtType<?>) declaration).getFormalTypeParameters().size() != 0;
-	}
-
 	@Override
 	public <T> void visitCtTypeAccess(CtTypeAccess<T> typeAccess) {
 		enterCtExpression(typeAccess);

src/test/java/spoon/test/targeted/TargetedExpressionTest.java

@@ -8,14 +8,12 @@
 import spoon.reflect.code.CtFieldRead;
 import spoon.reflect.code.CtFieldWrite;
 import spoon.reflect.code.CtInvocation;
-import spoon.reflect.code.CtReturn;
 import spoon.reflect.code.CtSuperAccess;
 import spoon.reflect.code.CtThisAccess;
 import spoon.reflect.code.CtTypeAccess;
 import spoon.reflect.declaration.CtAnonymousExecutable;
 import spoon.reflect.declaration.CtClass;
 import spoon.reflect.declaration.CtConstructor;
-import spoon.reflect.declaration.CtElement;
 import spoon.reflect.declaration.CtField;
 import spoon.reflect.declaration.CtMethod;
 import spoon.reflect.declaration.CtType;

src/test/java/spoon/test/visibility/VisibilityTest.java

@@ -5,13 +5,20 @@
 import spoon.OutputType;
 import spoon.SpoonAPI;
 import spoon.compiler.SpoonCompiler;
+import spoon.reflect.code.CtBinaryOperator;
+import spoon.reflect.code.CtFieldAccess;
+import spoon.reflect.code.CtUnaryOperator;
 import spoon.reflect.declaration.CtClass;
 import spoon.reflect.declaration.CtMethod;
+import spoon.reflect.declaration.CtType;
 import spoon.reflect.factory.Factory;
 import spoon.reflect.reference.CtFieldReference;
 import spoon.reflect.visitor.Query;
 import spoon.reflect.visitor.filter.AbstractReferenceFilter;
+import spoon.reflect.visitor.filter.TypeFilter;
 import spoon.test.TestUtils;
+import spoon.test.visibility.testclasses.A;
+import spoon.test.visibility.testclasses.A2;
 
 import java.io.File;
 import java.util.List;
@@ -63,14 +70,48 @@ public void testVisibilityOfClassesNamedByClassesInJavaLangPackage() throws Exce
 	}
 
 	@Test
-	public void testComplexVisibilityWithGenerics() throws Exception {
+	public void testFullyQualifiedNameOfTypeReferenceWithGeneric() throws Exception {
+		// contract: Generics are written when there are specified in the return type of a method.
+		final String target = "./target/spooned/spoon/test/visibility_generics/testclasses/";
 		final SpoonAPI launcher = new Launcher();
-		launcher.run(new String[] {
-				"-i", "./src/test/java/spoon/test/visibility/testclasses/A.java",
-				"-o", "./target/spooned/spoon/test/visibility_generics/testclasses/"
-		});
+		launcher.addInputResource("./src/test/java/spoon/test/visibility/testclasses/A.java");
+		launcher.addInputResource("./src/test/java/spoon/test/visibility/testclasses/A2.java");
+		launcher.addInputResource("./src/test/java/spoon/test/visibility/testclasses/Foo.java");
+		launcher.setSourceOutputDirectory(target);
+		launcher.run();
+
+		final CtClass<A> aClass = launcher.getFactory().Class().get(A.class);
+		CtType<?> nestedB = aClass.getNestedType("B");
+		List<CtFieldAccess> elements = nestedB.getElements(new TypeFilter<>(CtFieldAccess.class));
+		assertEquals(1, elements.size());
+		assertEquals("(spoon.test.visibility.testclasses.A.B.i)", elements.get(0).toString());
+
+		CtMethod<?> instanceOf = aClass.getMethodsByName("instanceOf").get(0);
+		List<CtBinaryOperator> elements1 = instanceOf.getElements(new TypeFilter<>(CtBinaryOperator.class));
+		assertEquals(1, elements1.size());
+		assertEquals("spoon.test.visibility.testclasses.A.B", elements1.get(0).getRightHandOperand().toString());
+
+		CtMethod<?> returnType = aClass.getMethodsByName("returnType").get(0);
+		assertEquals("spoon.test.visibility.testclasses.A<T>.C<T>", returnType.getType().toString());
+
+		final CtClass<A2> secondClass = launcher.getFactory().Class().get(A2.class);
+		nestedB = secondClass.getNestedType("B");
+		elements = nestedB.getElements(new TypeFilter<>(CtFieldAccess.class));
+		assertEquals(1, elements.size());
+		assertEquals("(spoon.test.visibility.testclasses.A2.B.i)", elements.get(0).toString());
+
+		instanceOf = secondClass.getMethodsByName("instanceOf").get(0);
+		elements1 = instanceOf.getElements(new TypeFilter<>(CtBinaryOperator.class));
+		assertEquals(1, elements1.size());
+		assertEquals("spoon.test.visibility.testclasses.A2.B", elements1.get(0).getRightHandOperand().toString());
+
+		returnType = secondClass.getMethodsByName("returnType").get(0);
+		assertEquals("spoon.test.visibility.testclasses.A2.C<java.lang.String>", returnType.getType().toString());
+
+		returnType = secondClass.getMethodsByName("returnType2").get(0);
+		assertEquals("spoon.test.visibility.testclasses.Foo<java.lang.String>.Bar<java.lang.String>", returnType.getType().toString());
 
-		TestUtils.canBeBuilt("./target/spooned/spoon/test/visibility_generics/testclasses/", 8);
+		TestUtils.canBeBuilt(target, 8);
 	}
 
 	@Test

src/test/java/spoon/test/visibility/testclasses/A.java

@@ -2,16 +2,20 @@
 
 public class A<T> {
 	public class B {
+		public static final int i = 0;
+		public boolean m(Object o) {
+			return i == 0;
+		}
 	}
 
 	public class C<T> {
 	}
 
-	public boolean m(Object o) {
+	public boolean instanceOf(Object o) {
 		return o instanceof A.B;
 	}
 
-	public C<T> m() {
+	public C<T> returnType() {
 		return new C<T>();
 	}
 

src/test/java/spoon/test/visibility/testclasses/A2.java

@@ -0,0 +1,48 @@
+/*
+ * Copyright (C) 2006-2015 INRIA and contributors
+ * Spoon - http://spoon.gforge.inria.fr/
+ *
+ * This software is governed by the CeCILL-C License under French law and
+ * abiding by the rules of distribution of free software. You can use, modify
+ * and/or redistribute the software under the terms of the CeCILL-C license as
+ * circulated by CEA, CNRS and INRIA at http://www.cecill.info.
+ *
+ * This program is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE. See the CeCILL-C License for more details.
+ *
+ * The fact that you are presently reading this means that you have had
+ * knowledge of the CeCILL-C license and that you accept its terms.
+ */
+
+package spoon.test.visibility.testclasses;
+
+public class A2 {
+	public class B {
+		public static final int i = 0;
+		public boolean m(Object o) {
+			return i == 0;
+		}
+	}
+
+	public class C<T> {
+	}
+
+	public boolean instanceOf(Object o) {
+		return o instanceof A2.B;
+	}
+
+	public C<String> returnType() {
+		return new C<String>();
+	}
+
+	public Foo<String>.Bar<String> returnType2(String s) {
+		return null;
+	}
+
+	public void aMethod() {
+		class D {
+		}
+		new D();
+	}
+}

src/test/java/spoon/test/visibility/testclasses/Foo.java

@@ -0,0 +1,23 @@
+/*
+ * Copyright (C) 2006-2015 INRIA and contributors
+ * Spoon - http://spoon.gforge.inria.fr/
+ *
+ * This software is governed by the CeCILL-C License under French law and
+ * abiding by the rules of distribution of free software. You can use, modify
+ * and/or redistribute the software under the terms of the CeCILL-C license as
+ * circulated by CEA, CNRS and INRIA at http://www.cecill.info.
+ *
+ * This program is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE. See the CeCILL-C License for more details.
+ *
+ * The fact that you are presently reading this means that you have had
+ * knowledge of the CeCILL-C license and that you accept its terms.
+ */
+
+package spoon.test.visibility.testclasses;
+
+public class Foo<T> {
+	public class Bar<C> {
+	}
+}