Make properties of type java.util.Optional implicitly optional.

skinny85 · Jan 21, 2024 · 0d85732 · 0d85732
1 parent 87f17f0
commit 0d85732
Show file tree

Hide file tree

Showing 5 changed files with 26 additions and 12 deletions.
diff --git a/src/main/java/org/jilt/internal/AbstractBuilderGenerator.java b/src/main/java/org/jilt/internal/AbstractBuilderGenerator.java
@@ -174,6 +174,12 @@ private boolean determineIfAttributeIsOptional(VariableElement attribute) {
         if (this.firstAnnotationCalledNullable(attribute) != null) {
             return true;
         }
+        TypeName attributeType = ClassName.get(attribute.asType());
+        // Optional most likely has a type parameter, so use toString() and startsWith()
+        // for comparison, disregarding the type parameter
+        if (attributeType.toString().startsWith("java.util.Optional")) {
+            return true;
+        }
         return false;
     }
 

diff --git a/src/main/java/org/jilt/internal/AbstractTypeSafeBuilderGenerator.java b/src/main/java/org/jilt/internal/AbstractTypeSafeBuilderGenerator.java
@@ -66,13 +66,15 @@ protected final String interfaceNameForAttribute(VariableElement attribute) {
         return interfaceNameFromBaseName(Utils.capitalize(attributeSimpleName(attribute)));
     }
 
-    protected final ParameterSpec setterParameterInInterface(VariableElement attribute) {
-        return this.setterParameter(attribute, this.attributeType(attribute));
+    protected final ParameterSpec setterParameterInInterface(VariableElement attribute,
+            boolean withMangledTypeParameters) {
+        return this.setterParameter(attribute, this.attributeType(attribute, withMangledTypeParameters));
     }
 
-    protected final TypeName attributeType(VariableElement attribute) {
+    protected final TypeName attributeType(VariableElement attribute,
+            boolean withMangledTypeParameters) {
         TypeName ret = TypeName.get(attribute.asType());
-        return this.mangleTypeName(ret);
+        return withMangledTypeParameters ? this.mangleTypeName(ret) : ret;
     }
 
     protected final String lastInterfaceName() {

diff --git a/src/main/java/org/jilt/internal/TypeSafeBuilderGenerator.java b/src/main/java/org/jilt/internal/TypeSafeBuilderGenerator.java
@@ -36,11 +36,12 @@ protected void generateClassesNeededByBuilder() throws Exception {
         for (VariableElement currentAttribute : attributes()) {
             boolean attributeIsOptional = this.isOptional(currentAttribute);
 
+            boolean mangleTypeParameters = !attributeIsOptional;
             MethodSpec setterMethod = MethodSpec
                     .methodBuilder(builderSetterMethodName(currentAttribute))
                     .addModifiers(Modifier.PUBLIC, Modifier.ABSTRACT)
-                    .returns(this.returnTypeForSetterFor(currentAttribute, !attributeIsOptional))
-                    .addParameter(this.setterParameterInInterface(currentAttribute))
+                    .returns(this.returnTypeForSetterFor(currentAttribute, mangleTypeParameters))
+                    .addParameter(this.setterParameterInInterface(currentAttribute, mangleTypeParameters))
                     .build();
 
             if (attributeIsOptional) {
@@ -57,7 +58,8 @@ protected void generateClassesNeededByBuilder() throws Exception {
             }
         }
 
-        this.addBuildMethodToInterface(optionalsInterfaceBuilder, /* withMangledTypeParameters */ false);
+        this.addBuildMethodToInterface(optionalsInterfaceBuilder,
+                /* withMangledTypeParameters */ false);
         outerInterfacesBuilder.addType(optionalsInterfaceBuilder.build());
 
         JavaFile javaFile = JavaFile

diff --git a/src/main/java/org/jilt/internal/TypeSafeUngroupedOptionalsBuilderGenerator.java b/src/main/java/org/jilt/internal/TypeSafeUngroupedOptionalsBuilderGenerator.java
@@ -43,12 +43,15 @@ protected void generateClassesNeededByBuilder() throws Exception {
                 innerInterfaceBuilder.addMethod(MethodSpec
                         .methodBuilder(builderSetterMethodName(currentAttribute))
                         .addModifiers(Modifier.PUBLIC, Modifier.ABSTRACT)
-                        .returns(this.returnTypeForSetterFor(currentAttribute, true))
-                        .addParameter(this.setterParameterInInterface(currentAttribute))
+                        .returns(this.returnTypeForSetterFor(currentAttribute,
+                                /* withMangledTypeParameters */ true))
+                        .addParameter(this.setterParameterInInterface(currentAttribute,
+                                /* withMangledTypeParameters */ true))
                         .build());
 
                 if (nextAttribute == null && isOptional(currentAttribute)) {
-                    this.addBuildMethodToInterface(innerInterfaceBuilder, /* withMangledTypeParameters */ true);
+                    this.addBuildMethodToInterface(innerInterfaceBuilder,
+                            /* withMangledTypeParameters */ true);
                 }
             } while (nextAttribute != null
                     && isOptional(currentAttribute)
@@ -62,7 +65,8 @@ && isOptional(currentAttribute)
                 .interfaceBuilder(lastInterfaceName())
                 .addModifiers(Modifier.PUBLIC, Modifier.STATIC)
                 .addTypeVariables(this.builderClassTypeParameters());
-        this.addBuildMethodToInterface(finalInterfaceBuilder, /* withMangledTypeParameters */ false);
+        this.addBuildMethodToInterface(finalInterfaceBuilder,
+                /* withMangledTypeParameters */ false);
         outerInterfacesBuilder.addType(finalInterfaceBuilder.build());
 
         JavaFile javaFile = JavaFile

diff --git a/src/test/java/org/jilt/test/OptionalsValueTest.java b/src/test/java/org/jilt/test/OptionalsValueTest.java
@@ -12,8 +12,8 @@ public class OptionalsValueTest {
     @Test
     public void optional_property_is_always_optional() {
         OptionalsValue<String, Integer> value = OptionalsValueBuilder.<String, Integer>optionalsValue()
-                .optional(Optional.of("abc"))
                 .t2(33)
+                .optional(Optional.of("abc"))
                 .build();
 
         assertThat(value.optional).contains("abc");