Keep class import when class is used as a type reference

When a class in `REQUIRE_STATIC_IMPORTS` appears as a type reference
(parameter, field, variable), its class import must be retained even if
all its method calls are converted to static imports. The pre-pass now
also visits `SimpleType` nodes to detect such usages.

Author: ksobolew

airstyle-core/src/main/java/io/airlift/airstyle/normalizer/StaticImportRuleNormalizer.java

@@ -21,6 +21,7 @@
 import org.eclipse.jdt.core.dom.ImportDeclaration;
 import org.eclipse.jdt.core.dom.MethodInvocation;
 import org.eclipse.jdt.core.dom.Name;
+import org.eclipse.jdt.core.dom.SimpleType;
 import org.eclipse.jdt.core.dom.rewrite.ASTRewrite;
 
 import java.util.ArrayList;
@@ -290,6 +291,16 @@ public boolean visit(MethodInvocation node)
                 }
                 return true;
             }
+
+            @Override
+            public boolean visit(SimpleType node)
+            {
+                String typeFqn = resolveClassName(node.getName(), importedClassesBySimpleName);
+                if (REQUIRE_STATIC_IMPORTS.containsKey(typeFqn)) {
+                    result.add(typeFqn);
+                }
+                return true;
+            }
         });
         return result;
     }

airstyle-core/src/test/java/io/airlift/airstyle/normalizer/TestStaticImportRuleNormalizer.java

@@ -240,6 +240,64 @@ String run(Map<String, Integer> values, List<String> names, Set<Integer> numbers
         assertFormatsOldToNew(oldCode, newCode);
     }
 
+    @Test
+    void testFormatterFixesRequiredStaticImportsWhenClassStillUsedAsParameter()
+    {
+        String oldCode =
+                """
+                import com.google.common.collect.ImmutableList;
+                import com.google.common.collect.ImmutableMap;
+                import com.google.common.collect.ImmutableSet;
+
+                class Test {
+                    String run(ImmutableMap<String, Integer> values, ImmutableList<String> names, ImmutableSet<Integer> numbers)
+                    {
+                        String mapped = values.entrySet().stream()
+                                .collect(ImmutableMap.toImmutableMap(Map.Entry::getKey, entry -> Math.toIntExact(entry.getValue())))
+                                .toString();
+                        String listed = names.stream()
+                                .collect(ImmutableList.toImmutableList())
+                                .toString();
+                        String settled = numbers.stream()
+                                .collect(ImmutableSet.toImmutableSet())
+                                .toString();
+                        return mapped + listed + settled;
+                    }
+                }
+                """;
+
+        String newCode =
+                """
+                import com.google.common.collect.ImmutableList;
+                import com.google.common.collect.ImmutableMap;
+                import com.google.common.collect.ImmutableSet;
+
+                import static com.google.common.collect.ImmutableList.toImmutableList;
+                import static com.google.common.collect.ImmutableMap.toImmutableMap;
+                import static com.google.common.collect.ImmutableSet.toImmutableSet;
+                import static java.lang.Math.toIntExact;
+
+                class Test
+                {
+                    String run(ImmutableMap<String, Integer> values, ImmutableList<String> names, ImmutableSet<Integer> numbers)
+                    {
+                        String mapped = values.entrySet().stream()
+                                .collect(toImmutableMap(Map.Entry::getKey, entry -> toIntExact(entry.getValue())))
+                                .toString();
+                        String listed = names.stream()
+                                .collect(toImmutableList())
+                                .toString();
+                        String settled = numbers.stream()
+                                .collect(toImmutableSet())
+                                .toString();
+                        return mapped + listed + settled;
+                    }
+                }
+                """;
+
+        assertFormatsOldToNew(oldCode, newCode);
+    }
+
     @Test
     void testFormatterFixesBannedPlainUtilityImports()
     {