Fix a bug where a nested parametrized type was not correctly mangled.

src/main/java/org/jilt/internal/AbstractBuilderGenerator.java

@@ -219,6 +219,22 @@ private List<TypeName> mangleTypeParameters(List<TypeName> typeParameters) {
                 // if this is a type variable, we need to mangle it
                 TypeVariableName typeVariableName = (TypeVariableName) typeParameter;
                 ret.add(this.mangleTypeParameter(typeVariableName));
+            } else if (typeParameter instanceof WildcardTypeName) {
+                WildcardTypeName wildcardTypeName = (WildcardTypeName) typeParameter;
+                List<TypeName> lowerBounds = this.mangleTypeParameters(wildcardTypeName.lowerBounds);
+                List<TypeName> upperBounds = this.mangleTypeParameters(wildcardTypeName.upperBounds);
+                if (!lowerBounds.isEmpty()) {
+                    ret.add(WildcardTypeName.supertypeOf(lowerBounds.get(0)));
+                } else if (!upperBounds.isEmpty()) {
+                    ret.add(WildcardTypeName.subtypeOf(upperBounds.get(0)));
+                } else {
+                    ret.add(typeParameter);
+                }
+            } else if (typeParameter instanceof ParameterizedTypeName) {
+                // if this is an entire parameterized type, we need to mangle it recursively
+                ParameterizedTypeName parameterizedTypeName = (ParameterizedTypeName) typeParameter;
+                ret.add(ParameterizedTypeName.get(parameterizedTypeName.rawType,
+                    this.mangleTypeParameters(parameterizedTypeName.typeArguments).toArray(new TypeName[]{})));
             } else {
                 ret.add(typeParameter);
             }
@@ -228,8 +244,8 @@ private List<TypeName> mangleTypeParameters(List<TypeName> typeParameters) {
 
     protected final TypeVariableName mangleTypeParameter(TypeVariableName typeVariableName) {
         return TypeVariableName.get(typeVariableName.name + "_",
-                // copy over the bounds unchanged, if there are any
-                typeVariableName.bounds.toArray(new TypeName[]{}));
+                // copy over the bounds, if there are any, recursively mangling them too
+                this.mangleTypeParameters(typeVariableName.bounds).toArray(new TypeName[]{}));
     }
 
     private ParameterSpec setterParameterSpec(VariableElement attribute, TypeName parameterType) {

src/test/java/org/jilt/test/OptionalsValueTest.java

@@ -6,8 +6,11 @@
 import org.jilt.test.data.optionals.OptionalsValueBuilder;
 import org.jilt.test.data.optionals.OptionalsWildcardValue;
 import org.jilt.test.data.optionals.OptionalsWildcardValueBuilder;
+import org.jilt.test.data.optionals.OptionalsWithOrderValue;
+import org.jilt.test.data.optionals.OptionalsWithOrderValueBuilder;
 import org.junit.Test;
 
+import java.util.Arrays;
 import java.util.Optional;
 
 import static org.assertj.core.api.Assertions.assertThat;
@@ -55,4 +58,14 @@ public void wildcard_optional_uses_java_lang_object_in_unwrapped_setter() {
 
         assertThat(value.wildcardOptional).isEqualTo(Optional.of(someObject));
     }
+
+    @Test
+    public void preserving_order_optional_works() {
+        OptionalsWithOrderValue<CharSequence> value = OptionalsWithOrderValueBuilder.<CharSequence>optionalsWithOrderValue()
+                .optional(Arrays.asList("a", "b"))
+                .v(null)
+                .build();
+
+        assertThat(value.optional).contains(Arrays.asList("a", "b"));
+    }
 }

src/test/java/org/jilt/test/data/optionals/OptionalsWithOrderValue.java

@@ -0,0 +1,18 @@
+package org.jilt.test.data.optionals;
+
+import org.jilt.Builder;
+import org.jilt.BuilderStyle;
+
+import java.util.List;
+import java.util.Optional;
+
+@Builder(style = BuilderStyle.STAGED_PRESERVING_ORDER)
+public final class OptionalsWithOrderValue<T> {
+    public final Optional<List<? extends T>> optional;
+    public final Void v;
+
+    public OptionalsWithOrderValue(Optional<List<? extends T>> optional, Void v) {
+        this.optional = optional;
+        this.v = v;
+    }
+}