Merge branch 'master' into fix-RemoveUnusedPrivateMethods

Author: Vincent Potucek

android/guava-bom/pom.xml

@@ -61,9 +61,6 @@
             <artifactId>central-publishing-maven-plugin</artifactId>
             <version>0.8.0</version>
             <extensions>true</extensions>
-            <configuration>
-              <publishingServerId>central</publishingServerId>
-            </configuration>
           </plugin>
         </plugins>
       </build>

android/guava-tests/test/com/google/common/base/StringsTest.java

@@ -213,6 +213,8 @@ public void testLenientFormat() {
     assertEquals("5 + 6 = 11", Strings.lenientFormat("5 + %s = 11", 6));
     assertEquals("5 + 6 = 11", Strings.lenientFormat("5 + 6 = %s", 11));
     assertEquals("5 + 6 = 11", Strings.lenientFormat("%s + %s = %s", 5, 6, 11));
+    assertEquals(
+        "5 + 6 = 11", Strings.lenientFormat("%s + %s = %s", (Object[]) new Integer[] {5, 6, 11}));
     assertEquals("null [null, null]", Strings.lenientFormat("%s", null, null, null));
     assertEquals("null [5, 6]", Strings.lenientFormat(null, 5, 6));
     assertEquals("null", Strings.lenientFormat("%s", (Object) null));

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

@@ -44,9 +44,11 @@ final class NullnessCasts {
    * doesn't work: Because nullness analyses typically infer the nullness of local variables,
    * there's no way to assign a {@code @Nullable T} to a field {@code T foo;} and instruct the
    * analysis that that means "plain {@code T}" rather than the inferred type {@code @Nullable T}.
-   * (Even if supported added {@code @NonNull}, that would not help, since the problem case
-   * addressed by this method is the case in which {@code T} has parametric nullness -- and thus its
-   * value may be legitimately {@code null}.)
+   * (And even if annotations on local variables were permitted as an optional hint, no annotation
+   * would be the right tool for the job here: {@code @Nullable} is the annotation that we're trying
+   * to get rid of, and {@code @NonNull} would be wrong for our use case for the same reason as
+   * {@code requireNonNull}: Our use case is the one in which {@code T} has parametric nullness—and
+   * thus its value may be legitimately {@code null}.)
    */
   @ParametricNullness
   @SuppressWarnings("nullness")

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

@@ -263,10 +263,6 @@ public static String lenientFormat(
 
     if (args == null) {
       args = new Object[] {"(Object[])null"};
-    } else {
-      for (int i = 0; i < args.length; i++) {
-        args[i] = lenientToString(args[i]);
-      }
     }
 
     // start substituting the arguments into the '%s' placeholders
@@ -279,18 +275,18 @@ public static String lenientFormat(
         break;
       }
       builder.append(template, templateStart, placeholderStart);
-      builder.append(args[i++]);
+      builder.append(lenientToString(args[i++]));
       templateStart = placeholderStart + 2;
     }
     builder.append(template, templateStart, template.length());
 
-    // if we run out of placeholders, append the extra args in square braces
+    // if we run out of placeholders, append the extra args in square brackets
     if (i < args.length) {
-      builder.append(" [");
-      builder.append(args[i++]);
-      while (i < args.length) {
-        builder.append(", ");
-        builder.append(args[i++]);
+      String prefix = " [";
+      for (; i < args.length; i++) {
+        builder.append(prefix);
+        builder.append(lenientToString(args[i]));
+        prefix = ", ";
       }
       builder.append(']');
     }

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

@@ -758,7 +758,7 @@ public NavigableSet<V> tailSet(@ParametricNullness V fromElement, boolean inclus
 
   /** List decorator that stays in sync with the multimap values for a key. */
   @WeakOuter
-  class WrappedList extends WrappedCollection implements List<V> {
+  private class WrappedList extends WrappedCollection implements List<V> {
     WrappedList(@ParametricNullness K key, List<V> delegate, @Nullable WrappedCollection ancestor) {
       super(key, delegate, ancestor);
     }

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

@@ -89,9 +89,11 @@
  * @author Jared Levy
  * @since 10.0
  */
+// We explicitly list `implements Table<...>` so that its `@Nullable V` appears in Javadoc.
+@SuppressWarnings("RedundancyRemover")
 @GwtCompatible
 public final class ArrayTable<R, C, V> extends AbstractTable<R, C, @Nullable V>
-    implements Serializable {
+    implements Table<R, C, @Nullable V>, Serializable {
 
   /**
    * Creates an {@code ArrayTable} filled with {@code null}.

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

@@ -44,9 +44,11 @@ final class NullnessCasts {
    * doesn't work: Because nullness analyses typically infer the nullness of local variables,
    * there's no way to assign a {@code @Nullable T} to a field {@code T foo;} and instruct the
    * analysis that that means "plain {@code T}" rather than the inferred type {@code @Nullable T}.
-   * (Even if supported added {@code @NonNull}, that would not help, since the problem case
-   * addressed by this method is the case in which {@code T} has parametric nullness -- and thus its
-   * value may be legitimately {@code null}.)
+   * (And even if annotations on local variables were permitted as an optional hint, no annotation
+   * would be the right tool for the job here: {@code @Nullable} is the annotation that we're trying
+   * to get rid of, and {@code @NonNull} would be wrong for our use case for the same reason as
+   * {@code requireNonNull}: Our use case is the one in which {@code T} has parametric nullness—and
+   * thus its value may be legitimately {@code null}.)
    */
   @ParametricNullness
   @SuppressWarnings("nullness")

android/guava/src/com/google/common/math/LongMath.java

@@ -534,7 +534,10 @@ public static long gcd(long a, long b) {
    * Returns the sum of {@code a} and {@code b}, provided it does not overflow.
    *
    * <p><b>Note:</b> this method is now unnecessary and should be treated as deprecated; use {@link
-   * Math#addExact(long, long)} instead.
+   * Math#addExact(long, long)} instead. Note that if both arguments are {@code int} values, writing
+   * {@code Math.addExact(a, b)} will call the {@link Math#addExact(int, int)} overload, not {@link
+   * Math#addExact(long, long)}. Also note that adding two {@code int} values can <b>never</b>
+   * overflow a {@code long}, so you can just write {@code (long) a + b}.
    *
    * @throws ArithmeticException if {@code a + b} overflows in signed {@code long} arithmetic
    */
@@ -547,7 +550,11 @@ public static long checkedAdd(long a, long b) {
    * Returns the difference of {@code a} and {@code b}, provided it does not overflow.
    *
    * <p><b>Note:</b> this method is now unnecessary and should be treated as deprecated; use {@link
-   * Math#subtractExact(long, long)} instead.
+   * Math#subtractExact(long, long)} instead. Note that if both arguments are {@code int} values,
+   * writing {@code Math.subtractExact(a, b)} will call the {@link Math#subtractExact(int, int)}
+   * overload, not {@link Math#subtractExact(long, long)}. Also note that subtracting two {@code
+   * int} values can <b>never</b> overflow a {@code long}, so you can just write {@code (long) a -
+   * b}.
    *
    * @throws ArithmeticException if {@code a - b} overflows in signed {@code long} arithmetic
    */
@@ -560,7 +567,11 @@ public static long checkedSubtract(long a, long b) {
    * Returns the product of {@code a} and {@code b}, provided it does not overflow.
    *
    * <p><b>Note:</b> this method is now unnecessary and should be treated as deprecated; use {@link
-   * Math#multiplyExact(long, long)} instead.
+   * Math#multiplyExact(long, long)} instead. Note that if both arguments are {@code int} values,
+   * writing {@code Math.multiplyExact(a, b)} will call the {@link Math#multiplyExact(int, int)}
+   * overload, not {@link Math#multiplyExact(long, long)}. Also note that multiplying two {@code
+   * int} values can <b>never</b> overflow a {@code long}, so you can just write {@code (long) a *
+   * b}.
    *
    * @throws ArithmeticException if {@code a * b} overflows in signed {@code long} arithmetic
    */

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

@@ -44,9 +44,11 @@ final class NullnessCasts {
    * doesn't work: Because nullness analyses typically infer the nullness of local variables,
    * there's no way to assign a {@code @Nullable T} to a field {@code T foo;} and instruct the
    * analysis that that means "plain {@code T}" rather than the inferred type {@code @Nullable T}.
-   * (Even if supported added {@code @NonNull}, that would not help, since the problem case
-   * addressed by this method is the case in which {@code T} has parametric nullness -- and thus its
-   * value may be legitimately {@code null}.)
+   * (And even if annotations on local variables were permitted as an optional hint, no annotation
+   * would be the right tool for the job here: {@code @Nullable} is the annotation that we're trying
+   * to get rid of, and {@code @NonNull} would be wrong for our use case for the same reason as
+   * {@code requireNonNull}: Our use case is the one in which {@code T} has parametric nullness—and
+   * thus its value may be legitimately {@code null}.)
    */
   @SuppressWarnings("nullness")
   @ParametricNullness