fix: fix regression when rewriting static field access

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

@@ -79,6 +79,9 @@ private boolean isSupertypeOfNewClass(CtTypeReference<?> typeRef) {
 	@Override
 	protected void handleTargetedExpression(CtTargetedExpression<?, ?> targetedExpression, LexicalScope nameScope) {
 		CtExpression<?> target = targetedExpression.getTarget();
+		if (target == null) {
+			return;
+		}
 		if (!target.isImplicit()) {
 			return;
 		}

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

@@ -6,6 +6,7 @@
 package spoon.reflect.visitor;
 
 import spoon.reflect.code.CtExpression;
+import spoon.reflect.code.CtFieldAccess;
 import spoon.reflect.code.CtTargetedExpression;
 import spoon.reflect.code.CtThisAccess;
 import spoon.reflect.code.CtTypeAccess;
@@ -67,6 +68,12 @@ protected void handleTypeReference(CtTypeReference<?> reference, LexicalScope na
 	@Override
 	protected void handleTargetedExpression(CtTargetedExpression<?, ?> targetedExpression, LexicalScope nameScope) {
 		CtExpression<?> target = targetedExpression.getTarget();
+		if (target == null) {
+			if (targetedExpression instanceof CtFieldAccess && ((CtFieldAccess) targetedExpression).getVariable().getDeclaringType() != null) {
+				((CtFieldAccess) targetedExpression).getVariable().getDeclaringType().setSimplyQualified(true);
+			}
+			return;
+		}
 		if (target.isImplicit()) {
 			return;
 		}

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

@@ -9,7 +9,6 @@
 import spoon.processing.AbstractProcessor;
 import spoon.processing.Processor;
 import spoon.reflect.code.CtConstructorCall;
-import spoon.reflect.code.CtExpression;
 import spoon.reflect.code.CtTargetedExpression;
 import spoon.reflect.declaration.CtCompilationUnit;
 import spoon.reflect.declaration.CtElement;
@@ -191,10 +190,6 @@ protected void onEnter(U context, CtRole role, CtElement element) {
 
 		if (element instanceof CtTargetedExpression) {
 			CtTargetedExpression<?, ?> targetedExpression = (CtTargetedExpression<?, ?>) element;
-			CtExpression<?> target = targetedExpression.getTarget();
-			if (target == null) {
-				return;
-			}
 			handleTargetedExpression(targetedExpression, context);
 		} else if (element instanceof CtTypeReference<?>) {
 			//we have to visit only PURE CtTypeReference. No CtArrayTypeReference, CtTypeParameterReference, ...

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

@@ -68,6 +68,14 @@ protected void handleTargetedExpression(CtTargetedExpression<?, ?> targetedExpre
 			return;
 		}
 		CtExpression<?> target = targetedExpression.getTarget();
+		if (target == null) {
+			if (targetedExpression instanceof CtFieldAccess
+				&& ((CtFieldAccess) targetedExpression).getVariable().getDeclaringType() != null
+				&& ((CtFieldAccess) targetedExpression).getVariable().getDeclaringType().isSimplyQualified()) {
+				context.addImport(((CtFieldAccess) targetedExpression).getVariable().getDeclaringType());
+			}
+			return;
+		}
 
 		if (target != null && target.isImplicit()) {
 			if (target instanceof CtTypeAccess) {

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

@@ -65,6 +65,9 @@ protected LexicalScope getScannerContextInformation() {
 	@Override
 	protected void handleTargetedExpression(CtTargetedExpression<?, ?> targetedExpression, LexicalScope nameScope) {
 		CtExpression<?> target = targetedExpression.getTarget();
+		if (target == null) {
+			return;
+		}
 		if (targetedExpression instanceof CtFieldAccess<?>) {
 			CtFieldAccess<?> fieldAccess = (CtFieldAccess<?>) targetedExpression;
 			if (target.isImplicit()) {

src/test/java/spoon/test/field/FieldTest.java

@@ -32,13 +32,15 @@
 import spoon.reflect.CtModel;
 import spoon.reflect.code.CtFieldRead;
 import spoon.reflect.code.CtReturn;
+import spoon.reflect.code.CtVariableAccess;
 import spoon.reflect.declaration.CtClass;
 import spoon.reflect.declaration.CtField;
 import spoon.reflect.declaration.CtMethod;
 import spoon.reflect.declaration.ModifierKind;
 import spoon.reflect.factory.Factory;
 import spoon.reflect.reference.CtFieldReference;
 import spoon.reflect.reference.CtTypeReference;
+import spoon.reflect.reference.CtVariableReference;
 import spoon.reflect.visitor.filter.TypeFilter;
 import spoon.support.reflect.eval.VisitorPartialEvaluator;
 import spoon.test.field.testclasses.A;
@@ -174,4 +176,37 @@ public void getFQNofFieldReference() {
 		assertEquals("field", fieldReference.getSimpleName());
 		assertEquals("<unknown>#field", fieldReference.getQualifiedName());
 	}
+
+	@Test
+	public void bugAfterRefactoringImports() {
+		Launcher launcher = new Launcher();
+		Factory factory = launcher.getFactory();
+		final CtClass<?> klass = factory.createClass("foo.A");
+
+		final CtFieldRead<Object> fieldRead = factory.createFieldRead();
+
+		final CtField<Object> negative_infinity = (CtField<Object>) factory.Class().get(Double.class).getField("NEGATIVE_INFINITY");
+		fieldRead.setVariable(negative_infinity.getReference());
+
+		launcher.getEnvironment().setAutoImports(false);
+		assertEquals("java.lang.Double.NEGATIVE_INFINITY", fieldRead.toString());
+
+		launcher.getEnvironment().setAutoImports(true);
+		assertEquals("Double.NEGATIVE_INFINITY", fieldRead.toString());
+
+		final CtField<Object> field = (CtField<Object>) factory.Class().get(File.class).getField("separator");
+		fieldRead.setVariable(field.getReference());
+		field.setDefaultExpression(fieldRead);
+		klass.addField(field);
+
+		launcher.getEnvironment().setAutoImports(true);
+		assertEquals("package foo;\n" +
+				"import java.io.File;\n" +
+				"class A {\n" +
+				"    public static final String separator = File.separator;\n" +
+				"}", klass.toStringWithImports());
+
+	}
+
+
 }