release of the Kotlin language.


Companion Imports
-----------------

The equivalent of static methods in Java is companion object functions in Kotlin. The bytecode is
the same but `.kt` files now need `Companion` in the import.

This works with OkHttp 3.x:

```kotlin
import okhttp3.CipherSuite.forJavaName
```

But OkHttp 4.x needs a `Companion`:

```kotlin

  /** Sorts the elements by their natural ordering. */
  /*
   * While the current implementation returns `this`, that's not something we mean to guarantee.
   * Callers of TestContainerGenerator.order need to be prepared for implementations to return a new
   * collection.
   */
  @SuppressWarnings("CanIgnoreReturnValueSuggester")
  @Override
  public List<String> order(List<String> insertionOrder) {

      implements Supplier<T>, Serializable {
    private transient Object lock = new Object();

    final Supplier<T> delegate;
    transient volatile boolean initialized;
    // "value" does not need to be volatile; visibility piggy-backs
    // on volatile read of "initialized".
    transient @Nullable T value;

    MemoizingSupplier(Supplier<T> delegate) {
      this.delegate = checkNotNull(delegate);
    }

    }

    /*
     * While the current implementation returns `this`, that's not something we mean to guarantee.
     * Callers of TestContainerGenerator.order need to be prepared for implementations to return a new
     * collection.
     */
    @SuppressWarnings("CanIgnoreReturnValueSuggester")
    @Override
    public List<String> order(List<String> insertionOrder) {

   * a duration in order to call a legacy API which requires a {@code long, TimeUnit} pair.
   */
  // We use this method only for cases in which we need to decompose to primitives.
  @SuppressWarnings({"GoodTime-ApiWithNumericTimeUnit", "GoodTime-DecomposeToPrimitive"})
  @IgnoreJRERequirement
  static long toNanosSaturated(Duration duration) {

 */
@GwtCompatible
public interface AsyncFunction<I extends @Nullable Object, O extends @Nullable Object> {
  /**
   * Returns an output {@code Future} to use in place of the given {@code input}. The output {@code
   * Future} need not be {@linkplain Future#isDone done}, making {@code AsyncFunction} suitable for
   * asynchronous derivations.
   *
   * <p>Throwing an exception from this method is equivalent to returning a failing {@code Future}.
   */

 * result.
 *
 * @since 20.0
 */
@FunctionalInterface
@GwtCompatible
public interface AsyncCallable<V extends @Nullable Object> {
  /**
   * Computes a result {@code Future}. The output {@code Future} need not be {@linkplain
   * Future#isDone done}, making {@code AsyncCallable} suitable for asynchronous derivations.
   *
   * <p>Throwing an exception from this method is equivalent to returning a failing {@link

 *     notifyAll();
 *   }
 * }
 * }
 *
 * <h3>{@code ReentrantLock}</h3>
 *
 * <p>This version is much more verbose than the {@code synchronized} version, and still suffers
 * from the need for the programmer to remember to use {@code while} instead of {@code if}. However,
 * one advantage is that we can introduce two separate {@code Condition} objects, which allows us to

 *     ExecutionException}, {@code UncheckedExecutionException}, and {@code ExecutionError}. Any
 *     code that is still catching {@code ComputationException} may need to be updated to catch some
 *     of those types instead. (Note that this type, though deprecated, is not planned to be removed
 *     from Guava.)
 */
@Deprecated
@GwtCompatible

 *     ExecutionException}, {@code UncheckedExecutionException}, and {@code ExecutionError}. Any
 *     code that is still catching {@code ComputationException} may need to be updated to catch some
 *     of those types instead. (Note that this type, though deprecated, is not planned to be removed
 *     from Guava.)
 */
@Deprecated
@GwtCompatible