public abstract class AnnotationValue<V> extends Member implements Comparable<AnnotationValue<?>> {

    private final V value;

    public AnnotationValue(String name, V value) {
        super(name);
        this.value = value;
    }

    public V getValue() {
        return value;
    }

    @Override
    public int compareTo(AnnotationValue<?> o) {
        return super.compare(o).result();

            AnnotationVisitor arrayVisitor = annotationVisitor.visitArray(name);
            AnnotationValue<?>[] values = ((ArrayAnnotationValue) value).getValue();
            for (AnnotationValue<?> annotationValue : values) {
                writeAnnotationValue(arrayVisitor, annotationValue);
            }
            arrayVisitor.visitEnd();
        } else if (value instanceof AnnotationAnnotationValue) {

        String annotationValue = ruleDefinition.getAnnotation(Model.class).value();
        String modelName = (annotationValue == null || annotationValue.isEmpty()) ? ruleDefinition.getMethodName() : annotationValue;

        try {
            ModelPath.validatePath(modelName);
        } catch (Exception e) {

 * limitations under the License.
 */

package org.gradle.internal.normalization.java.impl;

public class ArrayAnnotationValue extends AnnotationValue<AnnotationValue<?>[]> {

    public ArrayAnnotationValue(String name, AnnotationValue<?>[] value) {
        super(name, value);
    }

    private final SortedSet<AnnotationValue<?>> values = new TreeSet<>();
    private final boolean visible;

    public AnnotationMember(String name, boolean visible) {
        super(name);
        this.visible = visible;
    }

    public SortedSet<AnnotationValue<?>> getValues() {
        return ImmutableSortedSet.copyOf(values);
    }

    }

    public static Optional<? extends AnnotationValue> findAnnotationValue(AnnotationMirror annotation, String key) {
        return annotation.getElementValues().entrySet().stream().filter(it -> it.getKey().getSimpleName().toString().equals(key)).map(Map.Entry::getValue).findFirst();
    }

            AnnotationValue generatedClassName = AnnotationUtils.findAnnotationValue(annotationMirror, "generatedClassName")
                .orElseThrow(() -> new IllegalStateException("Annotation " + generatedClassNameProvidingAnnotation + " does not have a generatedClassName attribute"));

import org.objectweb.asm.Opcodes;

import java.util.LinkedList;
import java.util.List;

public class SortingAnnotationVisitor extends AnnotationVisitor {

    private final List<AnnotationValue<?>> annotationValues = new LinkedList<>();
    private final AnnotationMember annotation;

    private SortingAnnotationVisitor parentVisitor;
    private String annotationValueName;
    private String arrayValueName;

public class KaAnnotationApplicationValue @KaAnalysisApiInternals constructor(
    annotationValue: KaAnnotation,
    token: KaLifetimeToken
) : KaAnnotationValue(token) {
    public val annotationValue: KaAnnotation = annotationValue
        get() = withValidityAssertion { field }

    override val sourcePsi: KtElement?
        get() = withValidityAssertion { annotationValue.psi }
}

                .documentedAt(Documentation.userManual("id", "section"))
                .severity(annotationValue(propertyMetadata))
                .details("this is a test")
        );
    }

    private Severity annotationValue(PropertyMetadata propertyMetadata) {
        return propertyMetadata.getAnnotationForCategory(AnnotationCategory.TYPE)