@SuppressWarnings("serial") // uses writeReplace(), not default serialization
final class RegularImmutableList<E> extends ImmutableList<E> {
  static final ImmutableList<Object> EMPTY = new RegularImmutableList<>(new Object[0], 0);

  // The first `size` elements are non-null.
  @VisibleForTesting final transient @Nullable Object[] array;
  private final transient int size;

  RegularImmutableList(@Nullable Object[] array, int size) {
    this.array = array;

    return new RegularImmutableList<E>(ImmutableList.<E>nullCheckedList(e1, e2, e3));
  }

  public static <E> ImmutableList<E> of(E e1, E e2, E e3, E e4) {
    return new RegularImmutableList<E>(ImmutableList.<E>nullCheckedList(e1, e2, e3, e4));
  }

  public static <E> ImmutableList<E> of(E e1, E e2, E e3, E e4, E e5) {
    return new RegularImmutableList<E>(ImmutableList.<E>nullCheckedList(e1, e2, e3, e4, e5));
  }

    Object[] builderArray = builder.contents;
    for (int i = 0; i < 10; i++) {
      builder.add(i);
    }
    Object[] builderArrayAfterAdds = builder.contents;
    RegularImmutableList<Integer> list = (RegularImmutableList<Integer>) builder.build();
    Object[] listInternalArray = list.array;
    assertSame(builderArray, builderArrayAfterAdds);
    assertSame(builderArray, listInternalArray);
  }

    }
  }

  /** A singleton implementation of iterator() for the empty ImmutableList. */
  // TODO(b/345814817): Move this to RegularImmutableList?
  @SuppressWarnings("ClassInitializationDeadlock")
  private static final UnmodifiableListIterator<Object> EMPTY_ITR =
      new Itr<Object>(RegularImmutableList.EMPTY, 0);

  private static final class Itr<E> extends AbstractIndexedListIterator<E> {
    private final ImmutableList<E> list;

      builder.add("foo");
    }
    builder.add("bar");
    RegularImmutableSortedSet<String> set = (RegularImmutableSortedSet<String>) builder.build();
    RegularImmutableList<String> list = (RegularImmutableList<String>) set.elements;
    assertTrue(list.array.length <= 2 * set.size());
  }

  @GwtIncompatible("internals")
  public void testReusedBuilder() {

    Object[] builderArray = builder.contents;
    for (int i = 0; i < 10; i++) {
      builder.add(i);
    }
    Object[] builderArrayAfterAdds = builder.contents;
    RegularImmutableList<Integer> list = (RegularImmutableList<Integer>) builder.build();
    Object[] listInternalArray = list.array;
    assertSame(builderArray, builderArrayAfterAdds);
    assertSame(builderArray, listInternalArray);
  }

    assertEquals(HashMultiset.create(asList("a", "b", "a", "c")), multiset1);
    assertEquals(HashMultiset.create(asList("a", "b", "a", "c", "c")), multiset2);
    assertTrue(
        ((RegularImmutableList<String>)
                    ((RegularImmutableSortedMultiset<String>) multiset1).elementSet.elements)
                .array
            != builder.elements);
  }

  public void testBuilderAddAll() {

import static com.google.common.collect.CollectPreconditions.checkNonnegative;
import static com.google.common.collect.ObjectArrays.checkElementsNotNull;
import static com.google.common.collect.RegularImmutableList.EMPTY;
import static java.util.Objects.requireNonNull;

import com.google.common.annotations.GwtCompatible;
import com.google.common.annotations.GwtIncompatible;
import com.google.common.annotations.J2ktIncompatible;