// ordering.reverse() might be optimized, so let it do its thing
    return ordering.<T>reverse().<@NonNull S>nullsLast();
  }

  @SuppressWarnings("unchecked") // still need the right way to explain this
  @Override
  public <S extends @Nullable T> Ordering<@Nullable S> nullsFirst() {
    return (Ordering<@Nullable S>) this;
  }

  @Override

    private static final AtomicReferenceFieldUpdater<Waiter, @Nullable Thread> waiterThreadUpdater =
        AtomicReferenceFieldUpdater.<Waiter, @Nullable Thread>newUpdater(
            Waiter.class, Thread.class, "thread");
    private static final AtomicReferenceFieldUpdater<Waiter, @Nullable Waiter> waiterNextUpdater =
        AtomicReferenceFieldUpdater.<Waiter, @Nullable Waiter>newUpdater(
            Waiter.class, Waiter.class, "next");

 * invoke methods, they invoke methods on the {@code ForwardingSetMultimap}.
 *
 * @author Kurt Alfred Kluever
 * @since 3.0
 */
@GwtCompatible
public abstract class ForwardingSetMultimap<K extends @Nullable Object, V extends @Nullable Object>
    extends ForwardingMultimap<K, V> implements SetMultimap<K, V> {
  /** Constructor for use by subclasses. */
  public ForwardingSetMultimap() {}

  @Override

   *
   * @since 10.0
   */
  public static final class Wrapper<T extends @Nullable Object> implements Serializable {
    /*
     * Equivalence's type argument is always non-nullable: Equivalence<Number>, never
     * Equivalence<@Nullable Number>. That can still produce wrappers of various types --
     * Wrapper<Number>, Wrapper<Integer>, Wrapper<@Nullable Integer>, etc. If we used just

  }

  private static final ImmutableSet<String> NULLABLE_ANNOTATION_SIMPLE_NAMES =
      ImmutableSet.of("CheckForNull", "Nullable", "NullableDecl", "NullableType");

  static boolean isNullable(Invokable<?, ?> invokable) {
    return NULLNESS_ANNOTATION_READER.isNullable(invokable);
  }

  static boolean isNullable(Parameter param) {

@GwtIncompatible // not worth using in GWT for now
final class CompactLinkedHashMap<K extends @Nullable Object, V extends @Nullable Object>
    extends CompactHashMap<K, V> {
  // TODO(lowasser): implement removeEldestEntry so this can be used as a drop-in replacement

  /** Creates an empty {@code CompactLinkedHashMap} instance. */
  public static <K extends @Nullable Object, V extends @Nullable Object>
      CompactLinkedHashMap<K, V> create() {

                "Constructor com.example.Source(java.lang.String): Parameter 0 nullability changed from non-nullable to nullable",
                "Method com.example.SourceKt.invoke(com.example.Source,java.lang.String): Parameter 1 nullability changed from non-nullable to nullable"
            )
            assertHasNoInformation()
        }
    }

import org.jspecify.annotations.Nullable;

/**
 * Tests for {@code AbstractMapEntry}.
 *
 * @author Mike Bostock
 */
@GwtCompatible
@NullMarked
public class AbstractMapEntryTest extends TestCase {
  private static final @Nullable String NK = null;
  private static final @Nullable Integer NV = null;

  private static <K extends @Nullable Object, V extends @Nullable Object> Entry<K, V> entry(
      K key, V value) {

    private static final AtomicReferenceFieldUpdater<Waiter, @Nullable Thread> waiterThreadUpdater =
        AtomicReferenceFieldUpdater.<Waiter, @Nullable Thread>newUpdater(
            Waiter.class, Thread.class, "thread");
    private static final AtomicReferenceFieldUpdater<Waiter, @Nullable Waiter> waiterNextUpdater =
        AtomicReferenceFieldUpdater.<Waiter, @Nullable Waiter>newUpdater(
            Waiter.class, Waiter.class, "next");

import org.jspecify.annotations.NullMarked;
import org.jspecify.annotations.Nullable;

@GwtCompatible
@NullMarked
public class Helpers {
  // Clone of Objects.equals
  static boolean equal(@Nullable Object a, @Nullable Object b) {
    return a == b || (a != null && a.equals(b));
  }

  // Clone of Lists.newArrayList
  public static <E extends @Nullable Object> List<E> copyToList(Iterable<? extends E> elements) {