New feature: allow spoon to do static imports for methods and fields

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

@@ -143,7 +143,7 @@ public class DefaultJavaPrettyPrinter implements CtVisitor, PrettyPrinter {
 	public PrintingContext context = new PrintingContext();
 
 	/**
-	 * Handle imports of classes.
+	 * Handle classImports of classes.
 	 */
 	private ImportScanner importsContext;
 
@@ -225,15 +225,15 @@ protected void exitCtExpression(CtExpression<?> e) {
 	}
 
 	/**
-	 * Make the imports for a given type.
+	 * Make the classImports for a given type.
 	 */
-	public Collection<CtTypeReference<?>> computeImports(CtType<?> type) {
+	public Collection<CtReference> computeImports(CtType<?> type) {
 		context.currentTopLevel = type;
 		return importsContext.computeImports(context.currentTopLevel);
 	}
 
 	/**
-	 * Make the imports for all elements.
+	 * Make the classImports for all elements.
 	 */
 	public void computeImports(CtElement element) {
 		if (env.isAutoImports()) {
@@ -682,12 +682,22 @@ private <T> void printCtFieldAccess(CtFieldAccess<T> f) {
 				_context.ignoreGenerics(true);
 			}
 			if (f.getTarget() != null) {
-				if (!isInitializeStaticFinalField(f.getTarget())) {
+				boolean isInitializeStaticFinalField = isInitializeStaticFinalField(f.getTarget());
+				boolean isStaticField = f.getVariable().isStatic();
+				boolean isImportedField = importsContext.isImported(f.getVariable());
+
+				if (!isInitializeStaticFinalField && !(isStaticField && isImportedField)) {
 					printer.snapshotLength();
 					scan(f.getTarget());
 					if (printer.hasNewContent()) {
 						printer.write(".");
 					}
+				} else if (isStaticField && !isImportedField) {
+					CtTypeReference declaringType = f.getVariable().getDeclaringType();
+					if (declaringType != null) {
+						printer.write(declaringType.getSimpleName());
+						printer.write(".");
+					}
 				}
 				_context.ignoreStaticAccess(true);
 			}
@@ -1526,7 +1536,7 @@ public void visitCtWildcardReference(CtWildcardReference wildcardReference) {
 	}
 
 	private boolean printQualified(CtTypeReference<?> ref) {
-		if (importsContext.isImported(ref)) {
+		if (importsContext.isImported(ref) || (this.env.isAutoImports() && ref.getPackage() != null && ref.getPackage().getSimpleName().equals("java.lang"))) {
 			// If my.pkg.Something is imported, but
 			//A) we are in the context of a class which is also called "Something",
 			//B) we are in the context of a class which defines field which is also called "Something",
@@ -1722,7 +1732,7 @@ public void reset() {
 	@Override
 	public void calculate(CompilationUnit sourceCompilationUnit, List<CtType<?>> types) {
 		this.sourceCompilationUnit = sourceCompilationUnit;
-		Set<CtTypeReference<?>> imports = new HashSet<>();
+		Set<CtReference> imports = new HashSet<>();
 		for (CtType<?> t : types) {
 			imports.addAll(computeImports(t));
 		}

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

@@ -18,30 +18,30 @@
 
 import spoon.reflect.declaration.CtElement;
 import spoon.reflect.declaration.CtType;
-import spoon.reflect.reference.CtTypeReference;
+import spoon.reflect.reference.CtReference;
 
 import java.util.Collection;
 
 /**
- * Used to compute the imports required to write readable code with no fully qualified names.
+ * Used to compute the classImports required to write readable code with no fully qualified names.
  */
 public interface ImportScanner {
 	/**
 	 * Computes import of a {@link spoon.reflect.declaration.CtType}
 	 * (represent a class).
 	 *
-	 * @return Imports computes by Spoon, not original imports.
+	 * @return Imports computes by Spoon, it can be CtTypeReference (for classes), but also CtFieldReference (static field) or CtExecutableReference (static methods)
 	 */
-	Collection<CtTypeReference<?>> computeImports(CtType<?> simpleType);
+	Collection<CtReference> computeImports(CtType<?> simpleType);
 
 	/**
-	 * Computes imports for all elements.
+	 * Computes classImports for all elements.
 	 */
 	@Deprecated
 	void computeImports(CtElement element);
 
 	/**
 	 * Checks if the type is already imported.
 	 */
-	boolean isImported(CtTypeReference<?> ref);
+	boolean isImported(CtReference ref);
 }