Specifies that AutoValue should generate an implementation of the annotated class or interface, to serve as a builder for the value-type class it is nested within. As a simple example, here is an alternative way to write the Person class mentioned in the AutoValue example:

  @AutoValue
  abstract class Person {
    static Builder builder() {
      return new AutoValue_Person.Builder();
    }

    abstract String name();
    abstract int id();

    @AutoValue.Builder
    interface Builder {
      Builder name(String x);
      Builder id(int x);
      Person build();
    }
  }

Specifies that AutoValue should copy any annotations from the annotated element to the generated class. This annotation supports classes and methods.

The following annotations are excluded:

1. AutoValue and its nested annotations;
2. any annotation appearing in the AutoValue.CopyAnnotations#exclude field;
3. any class annotation which is itself annotated with the java.lang.annotation.Inherited meta-annotation.

For historical reasons, annotations are always copied from an @AutoValue property method to its implementation, unless @CopyAnnotations is present and explicitly excludes that annotation. But annotations are not copied from the @AutoValue class itself to its implementation unless @CopyAnnotations is present.

If you want to copy annotations from your @AutoValue-annotated class's methods to the generated fields in the AutoValue_... implementation, annotate your method with @AutoValue.CopyAnnotations. For example, if Example.java is:

  @Immutable
  @AutoValue
  abstract class Example {
    @CopyAnnotations
    @SuppressWarnings("Immutable") // justification ...
    abstract Object getObject();
    // other details ...
  }

Then AutoValue will generate the following AutoValue_Example.java:

  final class AutoValue_Example extends Example {
    @SuppressWarnings("Immutable")
    private final Object object;

    @SuppressWarnings("Immutable")
    @Override
    Object getObject() {
      return object;
    }

    // other details ...
  }

When the type of an @AutoValue property method has annotations, those are part of the type, so by default they are copied to the implementation of the method. But if a type annotation is mentioned in exclude then it is not copied.

For example, suppose @Confidential is a TYPE_USE annotation:

  @AutoValue
  abstract class Person {
    static Person create(@Confidential String name, int id) {
      return new AutoValue_Person(name, id);
    }

    abstract @Confidential String name();
    abstract int id();
  }

Then the implementation of the name() method will also have return type @Confidential String. But if name() were written like this...

    @AutoValue.CopyAnnotations(exclude = Confidential.class)
    abstract @Confidential String name();

...then the implementation of name() would have return type String without the annotation.