Add generic class/record support

junkfactory · junkfactory · commit 950284b8f7b6 · 2025-02-24T21:30:56.000-08:00
diff --git a/build.gradle.kts b/build.gradle.kts
@@ -32,7 +32,7 @@ tasks {
 
   patchPluginXml {
     sinceBuild.set("241")
-    untilBuild.set("243.*")
+    untilBuild.set("251.*")
   }
 
   signPlugin {
diff --git a/src/main/java/com/github/junkfactory/innerbuilder/generators/BuilderClassGenerator.java b/src/main/java/com/github/junkfactory/innerbuilder/generators/BuilderClassGenerator.java
@@ -20,7 +20,7 @@ public GenerationResult generate() {
         //builder constructor
         var builderClass = builderClassParams.builderClass();
         var builderConstructor = generateBuilderConstructor();
-        addMethod(builderClass, null, builderConstructor, false);
+        addMethod(builderClass.psiClass(), null, builderConstructor, false);
 
         var fieldsGenerator = generatorFactory.createBuilderFieldsGenerator(generatorParams, builderClassParams);
         fieldsGenerator.generate();
diff --git a/src/main/java/com/github/junkfactory/innerbuilder/generators/BuilderClassParams.java b/src/main/java/com/github/junkfactory/innerbuilder/generators/BuilderClassParams.java
@@ -1,18 +1,18 @@
 package com.github.junkfactory.innerbuilder.generators;
 
+import com.github.junkfactory.innerbuilder.generators.InnerBuilderGenerator.BuilderClass;
 import com.intellij.psi.PsiClass;
-import com.intellij.psi.PsiType;
 
-public record BuilderClassParams(PsiClass targetClass, PsiClass builderClass, PsiType builderType) {
+public record BuilderClassParams(PsiClass targetClass,
+                                 BuilderClass builderClass) {
 
     public static Builder builder() {
         return new Builder();
     }
 
     public static final class Builder {
         private PsiClass targetClass;
-        private PsiClass builderClass;
-        private PsiType builderType;
+        private BuilderClass builderClass;
 
         private Builder() {
         }
@@ -22,18 +22,13 @@ public Builder targetClass(PsiClass targetClass) {
             return this;
         }
 
-        public Builder builderClass(PsiClass builderClass) {
+        public Builder builderClass(BuilderClass builderClass) {
             this.builderClass = builderClass;
             return this;
         }
 
-        public Builder builderType(PsiType builderType) {
-            this.builderType = builderType;
-            return this;
-        }
-
         public BuilderClassParams build() {
-            return new BuilderClassParams(targetClass, builderClass, builderType);
+            return new BuilderClassParams(targetClass, builderClass);
         }
     }
 }
diff --git a/src/main/java/com/github/junkfactory/innerbuilder/generators/BuilderFieldsGenerator.java b/src/main/java/com/github/junkfactory/innerbuilder/generators/BuilderFieldsGenerator.java
@@ -30,10 +30,11 @@ public List<PsiField> getFields() {
     public GenerationResult generate() {
         PsiField lastAddedField = null;
         for (var fieldMember : generatorParams.psi().selectedFields()) {
-            lastAddedField = createOrUpdateField(builderClassParams.builderClass(), fieldMember, lastAddedField);
+            lastAddedField =
+                    createOrUpdateField(builderClassParams.builderClass().psiClass(), fieldMember, lastAddedField);
             fields.add(lastAddedField);
         }
-        cleanupFields(builderClassParams.builderClass());
+        cleanupFields(builderClassParams.builderClass().psiClass());
         return GenerationResult.NO_RESULT;
     }
 
diff --git a/src/main/java/com/github/junkfactory/innerbuilder/generators/BuilderMethodsGenerator.java b/src/main/java/com/github/junkfactory/innerbuilder/generators/BuilderMethodsGenerator.java
@@ -14,6 +14,9 @@
 
 class BuilderMethodsGenerator extends AbstractGenerator implements MethodsGenerator {
 
+    public record BuilderClassName(String className, String instanceClassName) {
+    }
+
     private final BuilderClassParams builderClassParams;
     private final FieldsGenerator fieldsGenerator;
 
@@ -38,17 +41,17 @@ public GenerationResult generate() {
         for (var field : fieldsGenerator.getFields()) {
             var setterMethod = generateFieldMethod(field);
             field.putCopyableUserData(UserDataKey.METHOD_REF, setterMethod.getName());
-            lastAddedElement = addMethod(builderClass, lastAddedElement, setterMethod, false);
+            lastAddedElement = addMethod(builderClass.psiClass(), lastAddedElement, setterMethod, false);
         }
 
         var options = generatorParams.options();
         if (options.contains(JavaInnerBuilderOption.WITH_VALIDATE_METHOD)) {
             var validateMethod = generateValidateMethod();
-            addMethod(builderClass, lastAddedElement, validateMethod, false);
+            addMethod(builderClass.psiClass(), lastAddedElement, validateMethod, false);
         }
 
         var buildMethod = generateBuildMethod(targetClass);
-        addMethod(builderClass, null, buildMethod, builderClassParams.targetClass().isRecord());
+        addMethod(builderClass.psiClass(), null, buildMethod, builderClassParams.targetClass().isRecord());
         return generationResult;
     }
 
@@ -92,7 +95,7 @@ private PsiMethod generatePutToMap(PsiField field, PsiMethod fieldPutMethod) {
         if (isPublic) {
             methodText.append(PsiModifier.PUBLIC).append(' ');
         }
-        methodText.append(BUILDER_CLASS_NAME)
+        methodText.append(builderClassParams.builderClass().builderType().getPresentableText())
                 .append(' ')
                 .append(methodName)
                 .append('(')
@@ -130,7 +133,7 @@ private PsiMethod generateAddToCollection(PsiField field, PsiMethod fieldAddMeth
         if (isPublic) {
             methodText.append(PsiModifier.PUBLIC).append(' ');
         }
-        methodText.append(BUILDER_CLASS_NAME)
+        methodText.append(builderClassParams.builderClass().builderType().getPresentableText())
                 .append(' ')
                 .append(methodName)
                 .append('(')
@@ -159,7 +162,7 @@ private PsiMethod generateBuilderSetter(PsiField field) {
         if (isPublic) {
             methodText.append(PsiModifier.PUBLIC).append(' ');
         }
-        methodText.append(BUILDER_CLASS_NAME)
+        methodText.append(builderClassParams.builderClass().builderType().getPresentableText())
                 .append(' ')
                 .append(fieldName)
                 .append('(')
@@ -180,10 +183,11 @@ private PsiMethod generateBuilderSetter(PsiField field) {
     }
 
     private PsiMethod generateBuildMethod(PsiClass targetClass) {
+        var targetClassName = Utils.buildClassName(targetClass.getName(), targetClass);
         var buildMethod = new StringBuilder()
                 .append(isPublic ? PsiModifier.PUBLIC : EMPTY)
                 .append(isPublic ? SPACE : EMPTY)
-                .append(targetClass.getName())
+                .append(targetClassName.className())
                 .append(" build() {");
         if (generatorParams.options().contains(JavaInnerBuilderOption.WITH_VALIDATE_METHOD)) {
             buildMethod.append("validate();");
@@ -193,13 +197,13 @@ private PsiMethod generateBuildMethod(PsiClass targetClass) {
                     .map(PsiField::getName)
                     .collect(Collectors.joining(", "));
             buildMethod.append("return new ")
-                    .append(targetClass.getName())
+                    .append(targetClassName.instanceClassName())
                     .append("(")
                     .append(recordParameters)
                     .append(");");
         } else {
             buildMethod.append("return new ")
-                    .append(targetClass.getName())
+                    .append(targetClassName.instanceClassName())
                     .append("(this);");
         }
         buildMethod.append("}");
diff --git a/src/main/java/com/github/junkfactory/innerbuilder/generators/InnerBuilderGenerator.java b/src/main/java/com/github/junkfactory/innerbuilder/generators/InnerBuilderGenerator.java
@@ -1,5 +1,6 @@
 package com.github.junkfactory.innerbuilder.generators;
 
+import com.github.junkfactory.innerbuilder.generators.BuilderMethodsGenerator.BuilderClassName;
 import com.github.junkfactory.innerbuilder.ui.JavaInnerBuilderOption;
 import com.intellij.codeInsight.generation.PsiFieldMember;
 import com.intellij.psi.PsiClass;
@@ -22,6 +23,12 @@
 
 class InnerBuilderGenerator extends AbstractGenerator implements Generator {
 
+    public record BuilderClass(PsiClass psiClass,
+                               PsiType builderType,
+                               BuilderClassName builderClassName,
+                               boolean genericType) {
+    }
+
     InnerBuilderGenerator(GeneratorFactory generatorFactory, GeneratorParams generatorParams) {
         super(generatorFactory, generatorParams);
     }
@@ -33,54 +40,51 @@ public GenerationResult generate() {
         if (targetClass == null || BUILDER_CLASS_NAME.equals(targetClass.getName())) {
             return NO_RESULT;
         }
-        var psiElementFactory = generatorParams.psi().factory();
         var builderClass = findOrCreateBuilderClass(targetClass);
-        var builderType = psiElementFactory.createTypeFromText(BUILDER_CLASS_NAME, targetClass);
 
         if (!targetClass.isRecord()) {
-            var constructor = generateTargetConstructor(targetClass, builderType);
+            var constructor = generateTargetConstructor(targetClass, builderClass);
             addMethod(targetClass, null, constructor, true);
         }
 
-        var newBuilderMethod = generateStaticBuilderMethod(targetClass, builderType);
+        var newBuilderMethod = generateStaticBuilderMethod(targetClass, builderClass);
         addMethod(targetClass, null, newBuilderMethod, false);
 
         // toBuilder method
         var options = generatorParams.options();
         if (options.contains(JavaInnerBuilderOption.WITH_TO_BUILDER_METHOD)) {
-            var toBuilderMethod = generateToBuilderMethod(targetClass, builderType,
+            var toBuilderMethod = generateToBuilderMethod(targetClass, builderClass,
                     generatorParams.psi().selectedFields());
             addMethod(targetClass, null, toBuilderMethod, true);
         }
 
         var params = BuilderClassParams.builder()
                 .targetClass(targetClass)
                 .builderClass(builderClass)
-                .builderType(builderType)
                 .build();
         var result = generatorFactory.createBuilderClassGenerator(generatorParams, params).generate();
         generationResult.merge(result);
         var codeStyleManager = generatorParams.psi().codeStyleManager();
         generationResult.when(ANNOTATIONS_ADDED, () -> codeStyleManager.shortenClassReferences(targetClass));
         generationResult.when(IMPORTS_ADDED, () -> codeStyleManager.removeRedundantImports((PsiJavaFile) file));
-        CodeStyleManager.getInstance(generatorParams.project()).reformat(builderClass);
+        CodeStyleManager.getInstance(generatorParams.project()).reformat(builderClass.psiClass());
         return generationResult;
     }
 
     private PsiMethod generateToBuilderMethod(PsiClass targetClass,
-                                              PsiType builderType,
+                                              BuilderClass builderClass,
                                               Collection<PsiFieldMember> fields) {
         var targetModifierList = Objects.requireNonNull(targetClass.getModifierList());
         boolean isPublic = targetModifierList.hasModifierProperty(PsiModifier.PUBLIC);
         var toBuilderMethod = new StringBuilder()
                 .append(isPublic ? PsiModifier.PUBLIC : EMPTY)
                 .append(isPublic ? SPACE : EMPTY)
-                .append(builderType.getPresentableText())
+                .append(builderClass.builderType().getPresentableText())
                 .append(SPACE)
                 .append(TO_BUILDER_NAME)
                 .append("() {")
                 .append("var builder = new ")
-                .append(builderType.getPresentableText())
+                .append(builderClass.builderType().getPresentableText())
                 .append("();");
         for (var member : fields) {
             var field = member.getElement();
@@ -97,9 +101,10 @@ private PsiMethod generateToBuilderMethod(PsiClass targetClass,
         return psiElementFactory.createMethodFromText(toBuilderMethod.toString(), targetClass);
     }
 
-    private PsiMethod generateStaticBuilderMethod(PsiClass targetClass, PsiType builderType) {
+    private PsiMethod generateStaticBuilderMethod(PsiClass targetClass, BuilderClass builderClass) {
         var psiElementFactory = generatorParams.psi().factory();
-        var newBuilderMethod = psiElementFactory.createMethod(BUILDER_METHOD_NAME, builderType);
+        var methodName = Utils.buildBuilderMethodName(builderClass.builderType());
+        var newBuilderMethod = psiElementFactory.createMethodFromText(methodName, targetClass);
         PsiUtil.setModifierProperty(newBuilderMethod, PsiModifier.STATIC, true);
         PsiUtil.setModifierProperty(newBuilderMethod, PsiModifier.PUBLIC, true);
 
@@ -108,18 +113,18 @@ private PsiMethod generateStaticBuilderMethod(PsiClass targetClass, PsiType buil
             existingMethod = newBuilderMethod;
             var newBuilderMethodBody = Objects.requireNonNull(existingMethod.getBody());
             var newStatement = psiElementFactory.createStatementFromText(String.format(
-                    "return new %s();", builderType.getPresentableText()), newBuilderMethod);
+                    "return new %s();", builderClass.builderClassName().instanceClassName()), newBuilderMethod);
             newBuilderMethodBody.add(newStatement);
         }
         return existingMethod;
     }
 
-    private PsiMethod generateTargetConstructor(final PsiClass targetClass, final PsiType builderType) {
+    private PsiMethod generateTargetConstructor(final PsiClass targetClass, BuilderClass builderClass) {
         var constructor = new StringBuilder()
                 .append("private ")
                 .append(targetClass.getName())
                 .append("(")
-                .append(builderType.getPresentableText())
+                .append(builderClass.builderType().getPresentableText())
                 .append(" builder) {");
 
         for (var member : generatorParams.psi().selectedFields()) {
@@ -151,19 +156,22 @@ private PsiMethod generateTargetConstructor(final PsiClass targetClass, final Ps
     }
 
     @NotNull
-    private PsiClass findOrCreateBuilderClass(final PsiClass targetClass) {
-        var builderClass = targetClass.findInnerClassByName(BUILDER_CLASS_NAME, false);
+    private BuilderClass findOrCreateBuilderClass(final PsiClass targetClass) {
+        var builderClassName = Utils.buildClassName(BUILDER_CLASS_NAME, targetClass);
+        var builderClass = targetClass.findInnerClassByName(builderClassName.className(), false);
         if (builderClass == null) {
-            return (PsiClass) targetClass.add(createBuilderClass(targetClass));
+            builderClass = (PsiClass) targetClass.add(createBuilderClass(targetClass, builderClassName.className()));
         }
 
-        return builderClass;
+        var psiElementFactory = generatorParams.psi().factory();
+        var builderType = psiElementFactory.createTypeFromText(builderClassName.className(), targetClass);
+        return new BuilderClass(builderClass, builderType, builderClassName, Utils.isGenericType(builderType));
     }
 
     @NotNull
-    private PsiClass createBuilderClass(final PsiClass targetClass) {
+    private PsiClass createBuilderClass(final PsiClass targetClass, String builderClassName) {
         String classDef = "public static final class " +
-                BUILDER_CLASS_NAME +
+                builderClassName +
                 " {}" +
                 System.lineSeparator();
         return generatorParams.psi().factory().createClassFromText(classDef, targetClass)
diff --git a/src/main/java/com/github/junkfactory/innerbuilder/generators/Utils.java b/src/main/java/com/github/junkfactory/innerbuilder/generators/Utils.java
@@ -1,7 +1,9 @@
 package com.github.junkfactory.innerbuilder.generators;
 
+import com.github.junkfactory.innerbuilder.generators.BuilderMethodsGenerator.BuilderClassName;
 import com.intellij.openapi.editor.Editor;
 import com.intellij.psi.PsiClass;
+import com.intellij.psi.PsiClassType;
 import com.intellij.psi.PsiField;
 import com.intellij.psi.PsiFile;
 import com.intellij.psi.PsiMethod;
@@ -19,6 +21,8 @@
 import java.util.Optional;
 import java.util.function.Predicate;
 
+import static com.github.junkfactory.innerbuilder.generators.AbstractGenerator.BUILDER_CLASS_NAME;
+
 public class Utils {
     @NonNls
     static final String JAVA_DOT_LANG = "java.lang.";
@@ -147,9 +151,52 @@ public static List<String> stringToList(String str) {
                 .toList();
     }
 
-    public static String parseType(String text) {
-        var parenthesisIndex = text.indexOf('(');
-        return parenthesisIndex == -1 ? text : text.substring(0, parenthesisIndex);
+    public static boolean isGenericType(PsiType psiType) {
+        // Check if the type is a PsiClassType
+        if (psiType instanceof PsiClassType classType) {
+            // Check if it has type parameters
+            return classType.getParameters().length > 0;
+        }
+        return false;
+    }
+
+    public static BuilderClassName buildClassName(String className, PsiClass targetClass) {
+        var builderClassName = new StringBuilder(className);
+        var typeParameters = targetClass.getTypeParameters();
+        if (typeParameters.length > 0) {
+            builderClassName.append('<');
+            for (int i = 0, l = typeParameters.length; i < l; i++) {
+                var typeParameter = typeParameters[i];
+                builderClassName.append(typeParameter.getName());
+                if (i < l - 1) {
+                    builderClassName.append(", ");
+                }
+            }
+            builderClassName.append('>');
+            return new BuilderClassName(builderClassName.toString(), "%s<>".formatted(className));
+        }
+        return new BuilderClassName(builderClassName.toString(), className);
+    }
+
+    public static String buildBuilderMethodName(PsiType builderType) {
+        var methodName = BUILDER_CLASS_NAME;
+        if (isGenericType(builderType)) {
+            var psiClassType = (PsiClassType) builderType;
+            var typeParameters = psiClassType.getParameters();
+            if (typeParameters.length > 0) {
+                var typeParameterNames = new StringBuilder();
+                for (int i = 0, l = typeParameters.length; i < l; i++) {
+                    var typeParameter = typeParameters[i];
+                    typeParameterNames.append(typeParameter.getPresentableText());
+                    if (i < l - 1) {
+                        typeParameterNames.append(", ");
+                    }
+                }
+                methodName = String.format("<%s> %s %s(){}", typeParameterNames,
+                        builderType.getPresentableText(), methodName);
+            }
+        }
+        return methodName;
     }
 
 }

Original file line number	Diff line number	Diff line change
`@@ -32,7 +32,7 @@ tasks {`
`32`	`32`
`33`	`33`	`patchPluginXml {`
`34`	`34`	`sinceBuild.set("241")`
`35`		`- untilBuild.set("243.*")`
	`35`	`+ untilBuild.set("251.*")`
`36`	`36`	`}`
`37`	`37`
`38`	`38`	`signPlugin {`
Original file line number	Diff line number	Diff line change
`@@ -1,18 +1,18 @@`
`1`	`1`	`package com.github.junkfactory.innerbuilder.generators;`
`2`	`2`
	`3`	`+import com.github.junkfactory.innerbuilder.generators.InnerBuilderGenerator.BuilderClass;`
`3`	`4`	`import com.intellij.psi.PsiClass;`
`4`		`-import com.intellij.psi.PsiType;`
`5`	`5`
`6`		`-public record BuilderClassParams(PsiClass targetClass, PsiClass builderClass, PsiType builderType) {`
	`6`	`+public record BuilderClassParams(PsiClass targetClass,`
	`7`	`+ BuilderClass builderClass) {`
`7`	`8`
`8`	`9`	`public static Builder builder() {`
`9`	`10`	`return new Builder();`
`10`	`11`	`}`
`11`	`12`
`12`	`13`	`public static final class Builder {`
`13`	`14`	`private PsiClass targetClass;`
`14`		`- private PsiClass builderClass;`
`15`		`- private PsiType builderType;`
	`15`	`+ private BuilderClass builderClass;`
`16`	`16`
`17`	`17`	`private Builder() {`
`18`	`18`	`}`
`@@ -22,18 +22,13 @@ public Builder targetClass(PsiClass targetClass) {`
`22`	`22`	`return this;`
`23`	`23`	`}`
`24`	`24`
`25`		`- public Builder builderClass(PsiClass builderClass) {`
	`25`	`+ public Builder builderClass(BuilderClass builderClass) {`
`26`	`26`	`this.builderClass = builderClass;`
`27`	`27`	`return this;`
`28`	`28`	`}`
`29`	`29`
`30`		`- public Builder builderType(PsiType builderType) {`
`31`		`- this.builderType = builderType;`
`32`		`- return this;`
`33`		`- }`
`34`		`-`
`35`	`30`	`public BuilderClassParams build() {`
`36`		`- return new BuilderClassParams(targetClass, builderClass, builderType);`
	`31`	`+ return new BuilderClassParams(targetClass, builderClass);`
`37`	`32`	`}`
`38`	`33`	`}`
`39`	`34`	`}`
Original file line number	Diff line number	Diff line change
`@@ -30,10 +30,11 @@ public List<PsiField> getFields() {`
`30`	`30`	`public GenerationResult generate() {`
`31`	`31`	`PsiField lastAddedField = null;`
`32`	`32`	`for (var fieldMember : generatorParams.psi().selectedFields()) {`
`33`		`- lastAddedField = createOrUpdateField(builderClassParams.builderClass(), fieldMember, lastAddedField);`
	`33`	`+ lastAddedField =`
	`34`	`+ createOrUpdateField(builderClassParams.builderClass().psiClass(), fieldMember, lastAddedField);`
`34`	`35`	`fields.add(lastAddedField);`
`35`	`36`	`}`
`36`		`- cleanupFields(builderClassParams.builderClass());`
	`37`	`+ cleanupFields(builderClassParams.builderClass().psiClass());`
`37`	`38`	`return GenerationResult.NO_RESULT;`
`38`	`39`	`}`
`39`	`40`