*       exceptions).
   * </ul>
   *
   * <p>The overall principle is to continue to treat every checked exception as a checked
   * exception, every unchecked exception as an unchecked exception, and every error as an error. In
   * addition, the cause of any {@code ExecutionException} is wrapped in order to ensure that the

                  // Other tests will verify what real, warning-free usage looks like
                  // but here we have to do some serious fudging
                  @Override
                  @SuppressWarnings({"unchecked", "rawtypes"})
                  public Map<Class, Impl> create(Object... elements) {
                    ImmutableClassToInstanceMap.Builder<Impl> builder =
                        ImmutableClassToInstanceMap.builder();

      @SuppressWarnings({"rawtypes", "unchecked"})
      Entry<Object, V>[] entries = new Entry[size];
      for (int i = 0; i < size; i++) {
        // requireNonNull is safe because the first `2*size` elements have been filled in.
        Object key = requireNonNull(alternatingKeysAndValues[2 * i]);
        @SuppressWarnings("unchecked")
        V value = (V) requireNonNull(alternatingKeysAndValues[2 * i + 1]);

      // `key` was in the cache, so it's a K.
      // (Or it's a weird case like a LinkedList in a Cache<ArrayList, ...>, but *shrug*.)
      @SuppressWarnings("unchecked")
      K castKey = (K) key;
      @SuppressWarnings("unchecked") // similar to the above
      V castValue = (V) value;

      alertListenerIfPresent(castKey, castValue, RemovalCause.EXPLICIT);
      remove(key);
      return true;
    }

  }

  private final class AsMapOfRanges extends IteratorBasedAbstractMap<Range<K>, V> {

    final Iterable<Entry<Range<K>, V>> entryIterable;

    @SuppressWarnings("unchecked") // it's safe to upcast iterables
    AsMapOfRanges(Iterable<RangeMapEntry<K, V>> entryIterable) {
      this.entryIterable = (Iterable) entryIterable;
    }

    @Override

                require(diagnostic is DiagnosticWithParameters1<*, *>)
                @Suppress("UNCHECKED_CAST")
                diagnostic.a as Collection<ResolvedCall<*>>
            }
            in diagnosticWithResolvedCallsAtPosition2 -> {
                require(diagnostic is DiagnosticWithParameters2<*, *, *>)
                @Suppress("UNCHECKED_CAST")
                diagnostic.b as Collection<ResolvedCall<*>>
            }

    Class<? super T> rawType = type.getRawType();
    @SuppressWarnings("unchecked") // Assume all default values are generics safe.
    T defaultValue = (T) defaultValues.getInstance(rawType);
    if (defaultValue != null) {
      return defaultValue;
    }
    @SuppressWarnings("unchecked") // ArbitraryInstances always returns generics-safe dummies.
    T value = (T) ArbitraryInstances.get(rawType);

 *
 * @author Chris Povirk
 */
@GwtCompatible(emulated = true)
@ElementTypesAreNonnullByDefault
final class Platform {
  /** Serializes and deserializes the specified object. */
  @SuppressWarnings("unchecked")
  static <T> T reserialize(T object) {
    checkNotNull(object);
    ByteArrayOutputStream bytes = new ByteArrayOutputStream();
    try {
      ObjectOutputStream out = new ObjectOutputStream(bytes);

 *
 * @author Chris Povirk
 */
@GwtCompatible(emulated = true)
@ElementTypesAreNonnullByDefault
final class Platform {
  /** Serializes and deserializes the specified object. */
  @SuppressWarnings("unchecked")
  static <T> T reserialize(T object) {
    checkNotNull(object);
    ByteArrayOutputStream bytes = new ByteArrayOutputStream();
    try {
      ObjectOutputStream out = new ObjectOutputStream(bytes);

      if (info.getName().endsWith("_gwt")) {
        Class<?> clazz = info.load();
        // TODO(cpovirk): why does asSubclass() throw? Is it something about ClassLoaders?
        @SuppressWarnings("unchecked")
        Class<? extends GWTTestCase> cast = (Class<? extends GWTTestCase>) clazz;
        suite.addTestSuite(cast);
      }
    }
    return suite;
  }