#1575 restoring GeneratedImportsModifier functionality

elucash · elucash · commit 8a43db906748 · 2025-07-23T21:24:41.000-04:00
diff --git a/generator/src/org/immutables/extgenerator/GeneratedImportsModifier.java b/generator/src/org/immutables/extgenerator/GeneratedImportsModifier.java
@@ -32,10 +32,15 @@ public interface GeneratedImportsModifier {
   /**
    * Modify imports set after import processing/extraction but before writing generated files.
    * Important to note that there are no way to change classnames as other parts of source file
-   * refers to class by simple name. However package-name part of imports may be rewritten.
+   * refers to class by simple name. However, package-name part of imports may be rewritten.
+   * <p>
+   * <em>Note: Before fully qualified class name there may be {@code static} keyword for static
+   * imports. Also import might contain {@code .*} suffix, while not typical, some templates
+   * might have these. But all automatic imports extracted by import rewriting tool will be
+   * just plain, non-static class imports and their import lines will be just fully qualified class names</em>
    * @param packageOfGeneratedFile informative package name of the generated file, may be used to
    *          employ different strategies for different packages.
-   * @param imports modifiables set of imports
+   * @param imports modifiable set of imports
    */
   void modify(String packageOfGeneratedFile, Set<String> imports);
 }
diff --git a/generator/src/org/immutables/generator/ImportRewriter.java b/generator/src/org/immutables/generator/ImportRewriter.java
@@ -7,11 +7,14 @@
 import java.util.List;
 import java.util.Map;
 import java.util.Objects;
+import java.util.ServiceLoader;
 import java.util.Set;
 import java.util.TreeSet;
 import java.util.function.Consumer;
 import java.util.stream.Collectors;
 import javax.annotation.Nullable;
+import com.google.common.collect.ImmutableList;
+import org.immutables.extgenerator.GeneratedImportsModifier;
 import static java.lang.Character.isJavaIdentifierPart;
 import static java.lang.Character.isJavaIdentifierStart;
 import static java.lang.Character.isLowerCase;
@@ -35,6 +38,10 @@
 public class ImportRewriter {
   private final CharSequence source;
 
+  static final ImmutableList<GeneratedImportsModifier> importsModifiers =
+      ImmutableList.copyOf(ServiceLoader.load(GeneratedImportsModifier.class,
+          PostprocessingMachine.class.getClassLoader()));
+
   private final int len;
   private int at;
 
@@ -82,15 +89,16 @@ private static final class Import extends Occurrence {
     final LinkedList<String> classSegments = new LinkedList<>();
     final StringBuilder name = new StringBuilder();
     boolean isStatic;
+    boolean isStar;
 
     @Override
     public String toString() {
-      return (packageSegments.isEmpty() ? "" : ("[" + String.join(".", packageSegments) + "]"))
-          + String.join(".", classSegments);
+      return (isStatic ? "static " : "") + asKey() + (isStar ? ".*" : "");
     }
 
     String asKey() {
-      return (packageSegments.isEmpty() ? "" : (String.join(".", packageSegments) + '.'))
+      return (packageSegments.isEmpty()
+          ? "" : (String.join(".", packageSegments) + (classSegments.isEmpty() ? "" : ".")))
           + String.join(".", classSegments);
     }
 
@@ -155,6 +163,22 @@ private String replace() {
     // these blocks were kept inline to better see overall work done
     // and preserve context/state of result content and sourceAt pointer
 
+    // append useful (non-skipped) imports to the end of our newImports set
+    for (Import imp : imports) {
+      if (imp.isStatic
+          || imp.isStar
+          || imp.classSegments.size() != 1
+          || !imp.packageSegments.equals(JAVA_LANG)) {
+
+        newImports.add(imp.toString());
+      }
+    }
+
+    // Run import modifiers if present on the classpath
+    for (GeneratedImportsModifier modifier : importsModifiers) {
+      modifier.modify(thisPackage, newImports);
+    }
+
     // Insert new imports
     if (!newImports.isEmpty()) {
       int insertAt = Math.max(beforeImportPosition, afterPackagePosition);
@@ -173,15 +197,11 @@ private String replace() {
       result.append("\n");
     }
 
+    // getting to the last of existing imports and setting position to the last one
+    // it's ok to just iterate in this way, extracting the last one if present is more trouble
     for (Import imp : imports) {
-      if (!imp.isStatic
-          && imp.classSegments.size() == 1
-          && imp.packageSegments.equals(JAVA_LANG)) {
-        // append everything since last position
-        result.append(source, sourceAt, imp.at);
-        // and skipping this import
-        sourceAt = imp.at + imp.len;
-      }
+      //result.append("//PARSED ").append(imp).append("\n");
+      sourceAt = imp.at + imp.len;
     }
 
     // Replace rewritten
@@ -660,6 +680,24 @@ private boolean processImport() {
 
         imp.range(begin, at - begin);
         addImport(imp);
+      } else if (consume('.')) {
+        // FIXME This case currently not working as consumeQualifiedName would go past the dot
+        consumeWhitespace();
+        if (consume('*')) {
+          consumeWhitespace();
+          if (consume(';')) {
+            imp.isStar = true;
+            imp.range(begin, at - begin);
+            addImport(imp);
+          }
+        }
+      } else if (consume('*')) {
+        consumeWhitespace();
+        if (consume(';')) {
+          imp.isStar = true;
+          imp.range(begin, at - begin);
+          addImport(imp);
+        }
       }
       // if we've not added import, we still recognized it to some degree, so return true
       // and not backtracking to begin
@@ -671,8 +709,10 @@ private boolean processImport() {
 
   private void addImport(Import imp) {
     imports.add(imp);
-    usages.put(imp.local(), imp.asKey());
-    //System.err.println("IMPORT " + (imp.isStatic ? "STATIC " : "") + imp);
+    // we can use condition !imp.isStar, but we use more general check
+    if (!imp.classSegments.isEmpty()) {
+      usages.put(imp.local(), imp.asKey());
+    }
   }
 
   private boolean processRecord() {
diff --git a/generator/src/org/immutables/generator/PostprocessingMachine.java b/generator/src/org/immutables/generator/PostprocessingMachine.java
@@ -43,9 +43,7 @@ public final class PostprocessingMachine {
 
   private static final Joiner JOINER = Joiner.on("");
 
-  private static final ImmutableList<GeneratedImportsModifier> importsModifiers =
-      ImmutableList.copyOf(ServiceLoader.load(GeneratedImportsModifier.class,
-          PostprocessingMachine.class.getClassLoader()));
+  private static final ImmutableList<GeneratedImportsModifier> importsModifiers = ImportRewriter.importsModifiers;
 
   private PostprocessingMachine() {}
 
