}

    this.values = values;
  }

  @Override
  final void collectOneValue(int index, @ParametricNullness V returnValue) {
    @RetainedLocalRef List<@Nullable Present<V>> localValues = values;
    if (localValues != null) {
      localValues.set(index, new Present<>(returnValue));
    }
  }

  @Override
  final void handleAllCompleted() {

import java.util.Map;

public class SinceAnnotationRule extends AbstractGradleViolationRule {

    public static final String SINCE_ERROR_MESSAGE = "Is not annotated with @since ";
    public static final String SINCE_MISMATCH_ERROR_MESSAGE = "Has invalid @since: it should be %s, but currently is %s";
    public static final String SINCE_INCONSISTENT_ERROR_MESSAGE = "Has inconsistent @since: %s";

      CollectorTester<T, A, R> of(
          Collector<T, A, R> collector, BiPredicate<? super R, ? super R> equivalence) {
    return new CollectorTester<>(collector, equivalence);
  }

  private final Collector<T, A, R> collector;
  private final BiPredicate<? super R, ? super R> equivalence;

  private CollectorTester(
      Collector<T, A, R> collector, BiPredicate<? super R, ? super R> equivalence) {
    this.collector = checkNotNull(collector);

                public class Source {
                    public final String @Nullable [] finalField = null;
                    public String @Nullable [] foo(String bar) { return null; }
                }
            """,
            v2 = """
                public class Source {
                    public final String[] finalField = new String[] {"bar"};

public class SecurityAuditLogger {

    private static final Logger auditLog = LoggerFactory.getLogger("SECURITY.AUDIT");
    private static final Logger log = LoggerFactory.getLogger(SecurityAuditLogger.class);

    private static final DateTimeFormatter ISO_FORMATTER = DateTimeFormatter.ISO_INSTANT;

    // Patterns for sensitive data - compiled once and cached
    private static final Pattern PASSWORD_PATTERN = Pattern.compile(

     */
    public static final String PATH_SEPARATOR = System.getProperty("path.separator");

    /**
     * <code>os.name</code> system property. Example: <code>Mac OS X</code>
     */
    public static final String OS_NAME = System.getProperty("os.name");

    /**
     * <code>java.io.tmpdir</code> system property. Example: /tmp
     */

  @Override
  @SuppressWarnings("unchecked")
  public final Entry<AnEnum, String>[] createArray(int length) {
    return (Entry<AnEnum, String>[]) new Entry<?, ?>[length];
  }

  @Override
  public final AnEnum[] createKeyArray(int length) {
    return new AnEnum[length];
  }

  @Override
  public final String[] createValueArray(int length) {
    return new String[length];
  }

/**
 * Pager class for character mapping management with pagination support.
 * Provides pagination functionality for character mapping lists.
 */
public class CharMappingPager implements Serializable {

    private static final long serialVersionUID = 1L;

    /** Total number of records across all pages. */
    private int allRecordCount;

    /** Total number of pages available. */
    private int allPageCount;

   */
  @CheckReturnValue
  public Converter<B, A> reverse() {
    Converter<B, A> result = reverse;
    return (result == null) ? reverse = new ReverseConverter<>(this) : result;
  }

  private static final class ReverseConverter<A, B> extends Converter<B, A>
      implements Serializable {
    final Converter<A, B> original;

 * anyway, so we just need to get by without the annotations here until Kotlin better understands
 * our other nullness annotations.
 */
final class Synchronized {
  private Synchronized() {}

  private static class SynchronizedObject implements Serializable {
    final Object delegate;
    final Object mutex;

    SynchronizedObject(Object delegate, @Nullable Object mutex) {
      this.delegate = checkNotNull(delegate);