feat: add meta-annotation for multi-level annotation propagation

Allow annotations to be inherited at multiple levels of the type hierarchy,
enabling both broad and specific configuration of mutators.

Use case: Configure mutators that share common types. For example, annotate
a fuzz test method to apply default settings to all String mutators, while
still allowing individual String parameters to override those settings with
different values.

Without this feature, an annotation could only appear once in the inheritance
chain, preventing this layered configuration approach.

Author: oetr

src/main/java/com/code_intelligence/jazzer/mutation/support/PropertyConstraintSupport.java

@@ -19,6 +19,7 @@
 import static com.code_intelligence.jazzer.mutation.support.TypeSupport.withExtraAnnotations;
 import static java.util.Arrays.stream;
 
+import com.code_intelligence.jazzer.mutation.utils.IgnoreRecursiveConflicts;
 import com.code_intelligence.jazzer.mutation.utils.PropertyConstraint;
 import java.lang.annotation.Annotation;
 import java.lang.reflect.AnnotatedType;
@@ -58,7 +59,8 @@ private static String constraintFrom(Annotation constraint) {
   }
 
   private static boolean hasConstraint(AnnotatedType target, Annotation constraint) {
-    return target.getAnnotation(constraint.annotationType()) != null;
+    return constraint.annotationType().getAnnotation(IgnoreRecursiveConflicts.class) == null
+        && target.getAnnotation(constraint.annotationType()) != null;
   }
 
   private PropertyConstraintSupport() {}

src/main/java/com/code_intelligence/jazzer/mutation/support/TypeSupport.java

@@ -27,6 +27,7 @@
 
 import com.code_intelligence.jazzer.mutation.annotation.NotNull;
 import com.code_intelligence.jazzer.mutation.annotation.WithLength;
+import com.code_intelligence.jazzer.mutation.utils.IgnoreRecursiveConflicts;
 import com.code_intelligence.jazzer.mutation.utils.PropertyConstraint;
 import java.lang.annotation.Annotation;
 import java.lang.annotation.Inherited;
@@ -578,6 +579,9 @@ private static Annotation[] checkExtraAnnotations(
               .collect(Collectors.toCollection(HashSet::new));
       for (Annotation annotation : extraAnnotations) {
         boolean added = existingAnnotationTypes.add(annotation.annotationType());
+        if (annotation.annotationType().isAnnotationPresent(IgnoreRecursiveConflicts.class)) {
+          continue;
+        }
         require(added, annotation + " already directly present on " + base);
       }
       return extraAnnotations;

src/main/java/com/code_intelligence/jazzer/mutation/utils/IgnoreRecursiveConflicts.java

@@ -0,0 +1,38 @@
+/*
+ * Copyright 2025 Code Intelligence GmbH
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.code_intelligence.jazzer.mutation.utils;
+
+import static java.lang.annotation.ElementType.ANNOTATION_TYPE;
+import static java.lang.annotation.RetentionPolicy.RUNTIME;
+
+import java.lang.annotation.Documented;
+import java.lang.annotation.Retention;
+import java.lang.annotation.Target;
+
+/**
+ * A meta-annotation to turn off the check in {@code checkExtraAnnotations} that throws if some
+ * annotation is present multiple times on a type. This allows annotations to be propagated down the
+ * type hierarchy and accumulated along the way.
+ *
+ * <p>E.g. {@code @A("data1") List<@A("data2") String> arg} - the String mutator can see of
+ * {@code @A("data1")} and {@code @A("data2")}, but the List mutator can only see
+ * {@code @A("data1")}.
+ */
+@Target(ANNOTATION_TYPE)
+@Retention(RUNTIME)
+@Documented
+public @interface IgnoreRecursiveConflicts {}