Improve handling of nullable properties in AutoBuilder:

- Support setters accepting `Optional` types for nullable properties.
- Support getters providing `Optional` types for nullable properties.

RELNOTES=AutoBuilder now allows `Optional` getters and setters to be used with nullable properties.
PiperOrigin-RevId: 887170824

Author: java-team-github-bot

value/src/it/functional/src/test/java/com/google/auto/value/AutoBuilderTest.java

@@ -41,6 +41,9 @@
 import java.util.NoSuchElementException;
 import java.util.Objects;
 import java.util.Optional;
+import java.util.OptionalDouble;
+import java.util.OptionalInt;
+import java.util.OptionalLong;
 import java.util.Set;
 import javax.lang.model.SourceVersion;
 import org.junit.Test;
@@ -779,4 +782,135 @@ public void builderTypeVariableWithNullableBound() {
         NullPointerException.class,
         () -> FrobCaller.<@Nullable String, String>caller().arg(null).notNull(null).call());
   }
+
+  static class NullablesExposedAsOptionals {
+    private final @Nullable String aString1;
+    private final @Nullable String aString2;
+    private final @Nullable Double aDouble;
+    private final @Nullable Integer anInt;
+    private final @Nullable Long aLong;
+
+    NullablesExposedAsOptionals(
+        @Nullable String aString1,
+        @Nullable String aString2,
+        @Nullable Double aDouble,
+        @Nullable Integer anInt,
+        @Nullable Long aLong) {
+      this.aString1 = aString1;
+      this.aString2 = aString2;
+      this.aDouble = aDouble;
+      this.anInt = anInt;
+      this.aLong = aLong;
+    }
+
+    Optional<String> aString1() {
+      return Optional.ofNullable(aString1);
+    }
+
+    com.google.common.base.Optional<String> aString2() {
+      return com.google.common.base.Optional.fromNullable(aString2);
+    }
+
+    OptionalDouble aDouble() {
+      return aDouble == null ? OptionalDouble.empty() : OptionalDouble.of(aDouble);
+    }
+
+    OptionalInt anInt() {
+      return anInt == null ? OptionalInt.empty() : OptionalInt.of(anInt);
+    }
+
+    OptionalLong aLong() {
+      return aLong == null ? OptionalLong.empty() : OptionalLong.of(aLong);
+    }
+
+    Builder toBuilder() {
+      return new AutoBuilder_AutoBuilderTest_NullablesExposedAsOptionals_Builder(this);
+    }
+
+    static Builder builder() {
+      return new AutoBuilder_AutoBuilderTest_NullablesExposedAsOptionals_Builder();
+    }
+
+    @AutoBuilder
+    abstract static class Builder {
+      abstract Builder setAString1(Optional<String> aString1);
+
+      abstract Builder setAString2(com.google.common.base.Optional<String> aString2);
+
+      abstract Builder setADouble(OptionalDouble aDouble);
+
+      abstract Builder setAnInt(OptionalInt anInt);
+
+      abstract Builder setALong(OptionalLong aLong);
+
+      abstract NullablesExposedAsOptionals build();
+    }
+  }
+
+  @Test
+  public void builderExposingNullableAsOptionalString() {
+    NullablesExposedAsOptionals built =
+        NullablesExposedAsOptionals.builder().setAString1(Optional.of("foo")).build();
+    assertThat(built.aString1()).hasValue("foo");
+    assertThat(built.toBuilder().build().aString1()).hasValue("foo");
+
+    NullablesExposedAsOptionals builtEmpty =
+        built.toBuilder().setAString1(Optional.empty()).build();
+    assertThat(builtEmpty.aString1()).isEmpty();
+    assertThat(builtEmpty.toBuilder().build().aString1()).isEmpty();
+  }
+
+  @Test
+  public void builderExposingNullableAsBaseOptionalString() {
+    NullablesExposedAsOptionals built =
+        NullablesExposedAsOptionals.builder()
+            .setAString2(com.google.common.base.Optional.of("foo"))
+            .build();
+    assertThat(built.aString2()).hasValue("foo");
+    assertThat(built.toBuilder().build().aString2()).hasValue("foo");
+
+    NullablesExposedAsOptionals builtAbsent =
+        built.toBuilder().setAString2(com.google.common.base.Optional.absent()).build();
+    assertThat(builtAbsent.aString2()).isAbsent();
+    assertThat(builtAbsent.toBuilder().build().aString2()).isAbsent();
+  }
+
+  @Test
+  public void builderExposingNullableAsOptionalDouble() {
+    NullablesExposedAsOptionals built =
+        NullablesExposedAsOptionals.builder().setADouble(OptionalDouble.of(3.14)).build();
+    assertThat(built.aDouble()).hasValue(3.14);
+    assertThat(built.toBuilder().build().aDouble()).hasValue(3.14);
+
+    NullablesExposedAsOptionals builtEmpty =
+        built.toBuilder().setADouble(OptionalDouble.empty()).build();
+    assertThat(builtEmpty.aDouble()).isEmpty();
+    assertThat(builtEmpty.toBuilder().build().aDouble()).isEmpty();
+  }
+
+  @Test
+  public void builderExposingNullableAsOptionalInt() {
+    NullablesExposedAsOptionals built =
+        NullablesExposedAsOptionals.builder().setAnInt(OptionalInt.of(3)).build();
+    assertThat(built.anInt()).hasValue(3);
+    assertThat(built.toBuilder().build().anInt()).hasValue(3);
+
+    NullablesExposedAsOptionals builtEmpty =
+        built.toBuilder().setAnInt(OptionalInt.empty()).build();
+    assertThat(builtEmpty.anInt()).isEmpty();
+    assertThat(builtEmpty.toBuilder().build().anInt()).isEmpty();
+  }
+
+  @Test
+  public void builderExposingNullableAsOptionalLong() {
+    NullablesExposedAsOptionals built =
+        NullablesExposedAsOptionals.builder().setALong(OptionalLong.of(3)).build();
+    assertThat(built.aLong()).hasValue(3);
+    assertThat(built.toBuilder().build().aLong()).hasValue(3);
+
+    NullablesExposedAsOptionals builtEmpty =
+        built.toBuilder().setALong(OptionalLong.empty()).build();
+    assertThat(builtEmpty.aLong()).isEmpty();
+    assertThat(builtEmpty.toBuilder().build().aLong()).isEmpty();
+  }
 }

value/src/it/functional/src/test/java/com/google/auto/value/AutoValueJava8Test.java

@@ -50,6 +50,8 @@
 import java.util.List;
 import java.util.Optional;
 import java.util.OptionalDouble;
+import java.util.OptionalInt;
+import java.util.OptionalLong;
 import java.util.Set;
 import java.util.function.Predicate;
 import java.util.stream.Stream;
@@ -1210,4 +1212,111 @@ public void typeParameterBuilderFieldsAreNullable() throws ReflectiveOperationEx
         .asList()
         .contains(nullable());
   }
+
+  @AutoValue
+  abstract static class NullablesExposedAsOptionals {
+    abstract @Nullable String maybeString();
+
+    abstract @Nullable Double maybeDouble();
+
+    abstract @Nullable Integer maybeInt();
+
+    abstract @Nullable Long maybeLong();
+
+    static Builder builder() {
+      return new AutoValue_AutoValueJava8Test_NullablesExposedAsOptionals.Builder();
+    }
+
+    @AutoValue.Builder
+    abstract static class Builder {
+      abstract Builder setMaybeString(Optional<String> maybeString);
+
+      abstract Builder setMaybeString(com.google.common.base.Optional<String> maybeString);
+
+      abstract Builder setMaybeDouble(OptionalDouble maybeDouble);
+
+      abstract Builder setMaybeInt(OptionalInt maybeInt);
+
+      abstract Builder setMaybeLong(OptionalLong maybeLong);
+
+      abstract NullablesExposedAsOptionals build();
+    }
+  }
+
+  @Test
+  public void testNullablesExposedAsOptionals_optionalString() {
+    assertThat(
+            NullablesExposedAsOptionals.builder()
+                .setMaybeString(Optional.of("foo"))
+                .build()
+                .maybeString())
+        .isEqualTo("foo");
+    assertThat(
+            NullablesExposedAsOptionals.builder()
+                .setMaybeString(Optional.empty())
+                .build()
+                .maybeString())
+        .isNull();
+  }
+
+  @Test
+  public void testNullablesExposedAsOptionals_baseOptionalString() {
+    assertThat(
+            NullablesExposedAsOptionals.builder()
+                .setMaybeString(com.google.common.base.Optional.of("foo"))
+                .build()
+                .maybeString())
+        .isEqualTo("foo");
+    assertThat(
+            NullablesExposedAsOptionals.builder()
+                .setMaybeString(com.google.common.base.Optional.absent())
+                .build()
+                .maybeString())
+        .isNull();
+  }
+
+  @Test
+  public void testNullablesExposedAsOptionals_optionalDouble() {
+    assertThat(
+            NullablesExposedAsOptionals.builder()
+                .setMaybeDouble(OptionalDouble.of(3.14))
+                .build()
+                .maybeDouble())
+        .isEqualTo(3.14);
+    assertThat(
+            NullablesExposedAsOptionals.builder()
+                .setMaybeDouble(OptionalDouble.empty())
+                .build()
+                .maybeDouble())
+        .isNull();
+  }
+
+  @Test
+  public void testNullablesExposedAsOptionals_optionalInt() {
+    assertThat(
+            NullablesExposedAsOptionals.builder().setMaybeInt(OptionalInt.of(3)).build().maybeInt())
+        .isEqualTo(3);
+    assertThat(
+            NullablesExposedAsOptionals.builder()
+                .setMaybeInt(OptionalInt.empty())
+                .build()
+                .maybeInt())
+        .isNull();
+  }
+
+  @Test
+  public void testNullablesExposedAsOptionals_optionalLong() {
+    assertThat(
+            NullablesExposedAsOptionals.builder()
+                .setMaybeLong(OptionalLong.of(3))
+                .build()
+                .maybeLong())
+        .isEqualTo(3);
+    assertThat(
+            NullablesExposedAsOptionals.builder()
+                .setMaybeLong(OptionalLong.empty())
+                .build()
+                .maybeLong())
+        .isNull();
+  }
 }