Add toImmutableSortedMap collectors that use the natural comparator.

RELNOTES=`collect`: Added `toImmutableSortedMap` collectors that use the natural comparator
PiperOrigin-RevId: 853789187

Author: java-team-github-bot

android/guava-tests/test/com/google/common/collect/ContiguousSetTest.java

@@ -282,7 +282,7 @@ public void testContains() {
     assertFalse(set.contains(4));
   }
 
-  // TODO: user - Enable when Kotlin throws expected CCE.
+  // TODO: https://youtrack.jetbrains.com/issue/KT-71001/ - Enable when Kotlin throws expected CCE.
   @J2ktIncompatible
   public void testContains_typeMismatch() {
     ImmutableSortedSet<Integer> set = ContiguousSet.create(Range.open(0, 4), integers());
@@ -299,7 +299,7 @@ public void testContainsAll() {
     }
   }
 
-  // TODO: user - Enable when Kotlin throws expected CCE.
+  // TODO: https://youtrack.jetbrains.com/issue/KT-71001/ - Enable when Kotlin throws expected CCE.
   @J2ktIncompatible
   public void testContainsAll_typeMismatch() {
     ImmutableSortedSet<Integer> set = ContiguousSet.create(Range.closed(1, 3), integers());

android/guava/src/com/google/common/base/Preconditions.java

@@ -458,7 +458,7 @@ public static void checkArgument(
    */
   public static void checkArgument(
       boolean expression,
-      // TODO: user - Make errorMessageTemplate consistently @Nullable across overloads.
+      // TODO: cl/604933487 - Make errorMessageTemplate consistently @Nullable across overloads.
       @Nullable String errorMessageTemplate,
       @Nullable Object p1,
       @Nullable Object p2) {

android/guava/src/com/google/common/collect/ImmutableSortedMap.java

@@ -63,6 +63,25 @@
 @GwtCompatible
 public final class ImmutableSortedMap<K, V> extends ImmutableMap<K, V>
     implements NavigableMap<K, V> {
+  /**
+   * Returns a {@link Collector} that accumulates elements into an {@code ImmutableSortedMap} whose
+   * keys and values are the result of applying the provided mapping functions to the input
+   * elements. The generated map is sorted by the natural ordering of the keys.
+   *
+   * <p>If the mapped keys contain duplicates, an {@code IllegalArgumentException} is thrown when
+   * the collection operation is performed. (This differs from the {@code Collector} returned by
+   * {@link Collectors#toMap(Function, Function)}, which throws an {@code IllegalStateException}.)
+   *
+   * @since NEXT
+   */
+  @IgnoreJRERequirement // Users will use this only if they're already using streams.
+  public static <T extends @Nullable Object, K extends Comparable<? super K>, V>
+      Collector<T, ?, ImmutableSortedMap<K, V>> toImmutableSortedMap(
+          Function<? super T, ? extends K> keyFunction,
+          Function<? super T, ? extends V> valueFunction) {
+    return CollectCollectors.toImmutableSortedMap(Ordering.natural(), keyFunction, valueFunction);
+  }
+
   /**
    * Returns a {@link Collector} that accumulates elements into an {@code ImmutableSortedMap} whose
    * keys and values are the result of applying the provided mapping functions to the input
@@ -84,14 +103,33 @@ public final class ImmutableSortedMap<K, V> extends ImmutableMap<K, V>
     return CollectCollectors.toImmutableSortedMap(comparator, keyFunction, valueFunction);
   }
 
+  /**
+   * Returns a {@link Collector} that accumulates elements into an {@code ImmutableSortedMap} whose
+   * keys and values are the result of applying the provided mapping functions to the input
+   * elements.
+   *
+   * <p>If the mapped keys contain duplicates, the values are merged using the specified merging
+   * function.
+   *
+   * @since NEXT
+   */
+  @IgnoreJRERequirement // Users will use this only if they're already using streams.
+  public static <T extends @Nullable Object, K extends Comparable<? super K>, V>
+      Collector<T, ?, ImmutableSortedMap<K, V>> toImmutableSortedMap(
+          Function<? super T, ? extends K> keyFunction,
+          Function<? super T, ? extends V> valueFunction,
+          BinaryOperator<V> mergeFunction) {
+    return CollectCollectors.toImmutableSortedMap(
+        Ordering.natural(), keyFunction, valueFunction, mergeFunction);
+  }
+
   /**
    * Returns a {@link Collector} that accumulates elements into an {@code ImmutableSortedMap} whose
    * keys and values are the result of applying the provided mapping functions to the input
    * elements.
    *
    * <p>If the mapped keys contain duplicates (according to the comparator), the values are merged
-   * using the specified merging function. Entries will appear in the encounter order of the first
-   * occurrence of the key.
+   * using the specified merging function.
    *
    * @since 33.2.0 (available since 21.0 in guava-jre)
    */

android/guava/src/com/google/common/util/concurrent/MoreExecutors.java

@@ -529,7 +529,7 @@ public final List<Runnable> shutdownNow() {
     }
 
     /*
-     * TODO: user - In addition to overriding `execute`, also
+     * TODO: https://github.com/google/guava/issues/2143 - In addition to overriding `execute`, also
      * override the `Future`-returning methods of `ExecutorService` to propagate cancellation from
      * our `TrustedListenableFutureTask` to a `Future` returned by the delegate executor?
      */

guava-gwt/src-super/com/google/common/collect/super/com/google/common/collect/ImmutableSortedMap.java

@@ -27,11 +27,9 @@
 import java.util.Iterator;
 import java.util.Map;
 import java.util.SortedMap;
-import java.util.TreeMap;
 import java.util.function.BinaryOperator;
 import java.util.function.Function;
 import java.util.stream.Collector;
-import java.util.stream.Collectors;
 import org.jspecify.annotations.Nullable;
 
 /**
@@ -62,6 +60,13 @@ public final class ImmutableSortedMap<K, V> extends ForwardingImmutableMap<K, V>
     this.sortedDelegate = delegate;
   }
 
+  public static <T extends @Nullable Object, K extends Comparable<? super K>, V>
+      Collector<T, ?, ImmutableSortedMap<K, V>> toImmutableSortedMap(
+          Function<? super T, ? extends K> keyFunction,
+          Function<? super T, ? extends V> valueFunction) {
+    return CollectCollectors.toImmutableSortedMap(Ordering.natural(), keyFunction, valueFunction);
+  }
+
   public static <T extends @Nullable Object, K, V>
       Collector<T, ?, ImmutableSortedMap<K, V>> toImmutableSortedMap(
           Comparator<? super K> comparator,
@@ -70,20 +75,23 @@ public final class ImmutableSortedMap<K, V> extends ForwardingImmutableMap<K, V>
     return CollectCollectors.toImmutableSortedMap(comparator, keyFunction, valueFunction);
   }
 
+  public static <T extends @Nullable Object, K extends Comparable<? super K>, V>
+      Collector<T, ?, ImmutableSortedMap<K, V>> toImmutableSortedMap(
+          Function<? super T, ? extends K> keyFunction,
+          Function<? super T, ? extends V> valueFunction,
+          BinaryOperator<V> mergeFunction) {
+    return CollectCollectors.toImmutableSortedMap(
+        Ordering.natural(), keyFunction, valueFunction, mergeFunction);
+  }
+
   public static <T extends @Nullable Object, K, V>
       Collector<T, ?, ImmutableSortedMap<K, V>> toImmutableSortedMap(
           Comparator<? super K> comparator,
           Function<? super T, ? extends K> keyFunction,
           Function<? super T, ? extends V> valueFunction,
           BinaryOperator<V> mergeFunction) {
-    checkNotNull(comparator);
-    checkNotNull(keyFunction);
-    checkNotNull(valueFunction);
-    checkNotNull(mergeFunction);
-    return Collectors.collectingAndThen(
-        Collectors.toMap(
-            keyFunction, valueFunction, mergeFunction, () -> new TreeMap<K, V>(comparator)),
-        ImmutableSortedMap::copyOfSorted);
+    return CollectCollectors.toImmutableSortedMap(
+        comparator, keyFunction, valueFunction, mergeFunction);
   }
 
   // unsafe, comparator() returns a comparator on the specified type

guava-tests/test/com/google/common/collect/ContiguousSetTest.java

@@ -282,7 +282,7 @@ public void testContains() {
     assertFalse(set.contains(4));
   }
 
-  // TODO: user - Enable when Kotlin throws expected CCE.
+  // TODO: https://youtrack.jetbrains.com/issue/KT-71001/ - Enable when Kotlin throws expected CCE.
   @J2ktIncompatible
   public void testContains_typeMismatch() {
     ImmutableSortedSet<Integer> set = ContiguousSet.create(Range.open(0, 4), integers());
@@ -299,7 +299,7 @@ public void testContainsAll() {
     }
   }
 
-  // TODO: user - Enable when Kotlin throws expected CCE.
+  // TODO: https://youtrack.jetbrains.com/issue/KT-71001/ - Enable when Kotlin throws expected CCE.
   @J2ktIncompatible
   public void testContainsAll_typeMismatch() {
     ImmutableSortedSet<Integer> set = ContiguousSet.create(Range.closed(1, 3), integers());

guava-tests/test/com/google/common/collect/ImmutableSortedMapTest.java

@@ -22,7 +22,6 @@
 import static com.google.common.collect.testing.Helpers.mapEntry;
 import static com.google.common.truth.Truth.assertThat;
 import static java.util.Collections.singletonMap;
-import static java.util.Comparator.naturalOrder;
 
 import com.google.common.annotations.GwtCompatible;
 import com.google.common.annotations.GwtIncompatible;
@@ -593,6 +592,25 @@ public void testBuilderComparator() {
   }
 
   public void testToImmutableSortedMap() {
+    Collector<Entry<String, Integer>, ?, ImmutableSortedMap<String, Integer>> collector =
+        toImmutableSortedMap(Entry::getKey, Entry::getValue);
+    BiPredicate<ImmutableSortedMap<String, Integer>, ImmutableSortedMap<String, Integer>>
+        equivalence =
+            Equivalence.equals()
+                .onResultOf(ImmutableSortedMap<String, Integer>::comparator)
+                .and(Equivalence.equals().onResultOf(map -> map.entrySet().asList()))
+                .and(Equivalence.equals());
+    ImmutableSortedMap<String, Integer> expected =
+        ImmutableSortedMap.<String, Integer>naturalOrder()
+            .put("one", 1)
+            .put("three", 3)
+            .put("two", 2)
+            .buildOrThrow();
+    CollectorTester.of(collector, equivalence)
+        .expectCollects(expected, mapEntry("one", 1), mapEntry("two", 2), mapEntry("three", 3));
+  }
+
+  public void testToImmutableSortedMap_withComparator() {
     Collector<Entry<String, Integer>, ?, ImmutableSortedMap<String, Integer>> collector =
         toImmutableSortedMap(String.CASE_INSENSITIVE_ORDER, Entry::getKey, Entry::getValue);
     BiPredicate<ImmutableSortedMap<String, Integer>, ImmutableSortedMap<String, Integer>>
@@ -606,22 +624,45 @@ public void testToImmutableSortedMap() {
             .put("one", 1)
             .put("three", 3)
             .put("two", 2)
-            .build();
+            .buildOrThrow();
     CollectorTester.of(collector, equivalence)
         .expectCollects(expected, mapEntry("one", 1), mapEntry("two", 2), mapEntry("three", 3));
   }
 
   public void testToImmutableSortedMap_exceptionOnDuplicateKey() {
     Collector<Entry<String, Integer>, ?, ImmutableSortedMap<String, Integer>> collector =
-        toImmutableSortedMap(Ordering.natural(), Entry::getKey, Entry::getValue);
+        toImmutableSortedMap(Entry::getKey, Entry::getValue);
+    assertThrows(
+        IllegalArgumentException.class,
+        () -> Stream.of(mapEntry("one", 1), mapEntry("one", 11)).collect(collector));
+  }
+
+  public void testToImmutableSortedMap_withComparator_exceptionOnDuplicateKey() {
+    Collector<Entry<String, Integer>, ?, ImmutableSortedMap<String, Integer>> collector =
+        toImmutableSortedMap(String.CASE_INSENSITIVE_ORDER, Entry::getKey, Entry::getValue);
     assertThrows(
         IllegalArgumentException.class,
         () -> Stream.of(mapEntry("one", 1), mapEntry("one", 11)).collect(collector));
   }
 
   public void testToImmutableSortedMapMerging() {
     Collector<Entry<String, Integer>, ?, ImmutableSortedMap<String, Integer>> collector =
-        toImmutableSortedMap(naturalOrder(), Entry::getKey, Entry::getValue, Integer::sum);
+        toImmutableSortedMap(Entry::getKey, Entry::getValue, Integer::sum);
+    Equivalence<ImmutableMap<String, Integer>> equivalence =
+        Equivalence.equals().<Entry<String, Integer>>pairwise().onResultOf(ImmutableMap::entrySet);
+    CollectorTester.of(collector, equivalence)
+        .expectCollects(
+            ImmutableSortedMap.of("one", 1, "three", 3, "two", 4),
+            mapEntry("one", 1),
+            mapEntry("two", 2),
+            mapEntry("three", 3),
+            mapEntry("two", 2));
+  }
+
+  public void testToImmutableSortedMapMerging_withComparator() {
+    Collector<Entry<String, Integer>, ?, ImmutableSortedMap<String, Integer>> collector =
+        toImmutableSortedMap(
+            String.CASE_INSENSITIVE_ORDER, Entry::getKey, Entry::getValue, Integer::sum);
     Equivalence<ImmutableMap<String, Integer>> equivalence =
         Equivalence.equals().<Entry<String, Integer>>pairwise().onResultOf(ImmutableMap::entrySet);
     CollectorTester.of(collector, equivalence)

guava/src/com/google/common/base/Preconditions.java

@@ -458,7 +458,7 @@ public static void checkArgument(
    */
   public static void checkArgument(
       boolean expression,
-      // TODO: user - Make errorMessageTemplate consistently @Nullable across overloads.
+      // TODO: cl/604933487 - Make errorMessageTemplate consistently @Nullable across overloads.
       @Nullable String errorMessageTemplate,
       @Nullable Object p1,
       @Nullable Object p2) {

guava/src/com/google/common/collect/ImmutableSortedMap.java

@@ -65,6 +65,24 @@
 @GwtCompatible
 public final class ImmutableSortedMap<K, V> extends ImmutableMap<K, V>
     implements NavigableMap<K, V> {
+  /**
+   * Returns a {@link Collector} that accumulates elements into an {@code ImmutableSortedMap} whose
+   * keys and values are the result of applying the provided mapping functions to the input
+   * elements. The generated map is sorted by the natural ordering of the keys.
+   *
+   * <p>If the mapped keys contain duplicates, an {@code IllegalArgumentException} is thrown when
+   * the collection operation is performed. (This differs from the {@code Collector} returned by
+   * {@link Collectors#toMap(Function, Function)}, which throws an {@code IllegalStateException}.)
+   *
+   * @since NEXT
+   */
+  public static <T extends @Nullable Object, K extends Comparable<? super K>, V>
+      Collector<T, ?, ImmutableSortedMap<K, V>> toImmutableSortedMap(
+          Function<? super T, ? extends K> keyFunction,
+          Function<? super T, ? extends V> valueFunction) {
+    return CollectCollectors.toImmutableSortedMap(Ordering.natural(), keyFunction, valueFunction);
+  }
+
   /**
    * Returns a {@link Collector} that accumulates elements into an {@code ImmutableSortedMap} whose
    * keys and values are the result of applying the provided mapping functions to the input
@@ -85,14 +103,32 @@ public final class ImmutableSortedMap<K, V> extends ImmutableMap<K, V>
     return CollectCollectors.toImmutableSortedMap(comparator, keyFunction, valueFunction);
   }
 
+  /**
+   * Returns a {@link Collector} that accumulates elements into an {@code ImmutableSortedMap} whose
+   * keys and values are the result of applying the provided mapping functions to the input
+   * elements.
+   *
+   * <p>If the mapped keys contain duplicates, the values are merged using the specified merging
+   * function.
+   *
+   * @since NEXT
+   */
+  public static <T extends @Nullable Object, K extends Comparable<? super K>, V>
+      Collector<T, ?, ImmutableSortedMap<K, V>> toImmutableSortedMap(
+          Function<? super T, ? extends K> keyFunction,
+          Function<? super T, ? extends V> valueFunction,
+          BinaryOperator<V> mergeFunction) {
+    return CollectCollectors.toImmutableSortedMap(
+        Ordering.natural(), keyFunction, valueFunction, mergeFunction);
+  }
+
   /**
    * Returns a {@link Collector} that accumulates elements into an {@code ImmutableSortedMap} whose
    * keys and values are the result of applying the provided mapping functions to the input
    * elements.
    *
    * <p>If the mapped keys contain duplicates (according to the comparator), the values are merged
-   * using the specified merging function. Entries will appear in the encounter order of the first
-   * occurrence of the key.
+   * using the specified merging function.
    *
    * @since 21.0
    */

guava/src/com/google/common/util/concurrent/MoreExecutors.java

@@ -526,7 +526,7 @@ public final List<Runnable> shutdownNow() {
     }
 
     /*
-     * TODO: user - In addition to overriding `execute`, also
+     * TODO: https://github.com/google/guava/issues/2143 - In addition to overriding `execute`, also
      * override the `Future`-returning methods of `ExecutorService` to propagate cancellation from
      * our `TrustedListenableFutureTask` to a `Future` returned by the delegate executor?
      */