// test without that cast to verify that using the raw Comparable works outside J2KT.
  @J2ktIncompatible // J2KT's translation of raw Comparable is not a supertype of Int translation
  public void testCreation_expectedSize() {
    MinMaxPriorityQueue<Integer> queue = MinMaxPriorityQueue.expectedSize(8).create();
    assertEquals(8, queue.capacity());
    checkUnbounded(queue);

 * <i>type</i> offering meaningful behavioral guarantees. This is substantially different from the
 * case of (say) {@link HashSet}, which is an <i>implementation</i>, with semantics that were
 * largely defined by its supertype.
 *
 * <p>For field types and method return types, you should generally use the immutable type (such as
 * {@link ImmutableList}) instead of the general collection interface type (such as {@link List}).

   * that use {@code comparator} to determine the least and greatest elements.
   */
  /*
   * TODO(cpovirk): Change to Comparator<? super B> to permit Comparator<@Nullable ...> and
   * Comparator<SupertypeOfB>? What we have here matches the immutable collections, but those also
   * expose a public Builder constructor that accepts "? super." So maybe we should do *that*
   * instead.
   */

    Arrays.fill(nextInInsertionOrder, 0, size, ABSENT);
    size = 0;
    firstInInsertionOrder = ENDPOINT;
    lastInInsertionOrder = ENDPOINT;
    modCount++;
  }

  /** Shared supertype of keySet, values, entrySet, and inverse.entrySet. */
  abstract static class View<
          K extends @Nullable Object, V extends @Nullable Object, T extends @Nullable Object>
      extends AbstractSet<T> {

   * that use {@code comparator} to determine the least and greatest elements.
   */
  /*
   * TODO(cpovirk): Change to Comparator<? super B> to permit Comparator<@Nullable ...> and
   * Comparator<SupertypeOfB>? What we have here matches the immutable collections, but those also
   * expose a public Builder constructor that accepts "? super." So maybe we should do *that*
   * instead.
   */

  // test without that cast to verify that using the raw Comparable works outside J2KT.
  @J2ktIncompatible // J2KT's translation of raw Comparable is not a supertype of Int translation
  public void testCreation_expectedSize() {
    MinMaxPriorityQueue<Integer> queue = MinMaxPriorityQueue.expectedSize(8).create();
    assertEquals(8, queue.capacity());
    checkUnbounded(queue);

     * ImmutableSortedMultiset#orderedBy(Comparator)}.
     */
    @SuppressWarnings("unchecked")
    public Builder(Comparator<? super E> comparator) {
      super(true); // doesn't allocate hash table in supertype
      this.comparator = checkNotNull(comparator);
      this.elements = (E[]) new Object[ImmutableCollection.Builder.DEFAULT_INITIAL_CAPACITY];
      this.counts = new int[ImmutableCollection.Builder.DEFAULT_INITIAL_CAPACITY];

      public <S extends Set<E>> S copyInto(S set) {
        set.addAll(set1);
        set.addAll(set2);
        return set;
      }

      @Override
      @SuppressWarnings({"nullness", "unchecked"}) // see supertype
      public ImmutableSet<@NonNull E> immutableCopy() {
        ImmutableSet.Builder<@NonNull E> builder =
            new ImmutableSet.Builder<@NonNull E>()
                .addAll((Iterable<@NonNull E>) set1)

}

func (c *typeConv) badCFType(dt *dwarf.TypedefType) bool {
	// The real bad types are CFNumberRef and CFDateRef.
	// Sometimes non-pointers are stored in these types.
	// CFTypeRef is a supertype of those, so it can have bad pointers in it as well.
	// We return true for the other *Ref types just so casting between them is easier.
	// We identify the correct set of types as those ending in Ref and for which