keep bundle annotations and prevent simple cycles

I don't see any downsides and this makes it easier to manipulate
custom annotations, introspectors, serializers, and other parts
that interact with annotated objects. The cycle detection is a
bonus.

Author: tea-dragon

src/main/java/com/fasterxml/jackson/databind/introspect/AnnotatedClass.java

@@ -908,13 +908,13 @@ private void _addAnnotationsIfNotPresent(AnnotationMap result, Annotation[] anns
         if (anns != null) {
             List<Annotation[]> bundles = null;
             for (Annotation ann : anns) { // first: direct annotations
-                if (_isAnnotationBundle(ann)) {
+                // note: we will NOT filter out non-Jackson anns any more
+                boolean wasNotPresent = result.addIfNotPresent(ann);
+                if (wasNotPresent && _isAnnotationBundle(ann)) {
                     if (bundles == null) {
                         bundles = new LinkedList<Annotation[]>();
                     }
                     bundles.add(ann.annotationType().getDeclaredAnnotations());
-                } else { // note: we will NOT filter out non-Jackson anns any more
-                    result.addIfNotPresent(ann);
                 }
             }
             if (bundles != null) { // and secondarily handle bundles, if any found: precedence important
@@ -930,13 +930,13 @@ private void _addAnnotationsIfNotPresent(AnnotatedMember target, Annotation[] an
         if (anns != null) {
             List<Annotation[]> bundles = null;
             for (Annotation ann : anns) { // first: direct annotations
-                if (_isAnnotationBundle(ann)) {
+                // note: we will NOT filter out non-Jackson anns any more
+                boolean wasNotPresent = target.addIfNotPresent(ann);
+                if (wasNotPresent && _isAnnotationBundle(ann)) {
                     if (bundles == null) {
                         bundles = new LinkedList<Annotation[]>();
                     }
                     bundles.add(ann.annotationType().getDeclaredAnnotations());
-                } else { // note: we will NOT filter out non-Jackson anns any more
-                    target.addIfNotPresent(ann);
                 }
             }
             if (bundles != null) { // and secondarily handle bundles, if any found: precedence important

src/main/java/com/fasterxml/jackson/databind/introspect/AnnotatedMember.java

@@ -51,17 +51,17 @@ protected AnnotationMap getAllAnnotations() {
      * annotation masking or overriding an annotation 'real' constructor
      * has.
      */
-    public final void addOrOverride(Annotation a) {
-        _annotations.add(a);
+    public final boolean addOrOverride(Annotation a) {
+        return _annotations.add(a);
     }
 
     /**
      * Method called to augment annotations, by adding specified
      * annotation if and only if it is not yet present in the
      * annotation map we have.
      */
-    public final void addIfNotPresent(Annotation a) {
-        _annotations.addIfNotPresent(a);
+    public final boolean addIfNotPresent(Annotation a) {
+        return _annotations.addIfNotPresent(a);
     }
 
     /**

src/main/java/com/fasterxml/jackson/databind/introspect/AnnotationMap.java

@@ -71,18 +71,20 @@ public int size() {
      * Method called to add specified annotation in the Map, but
      * only if it didn't yet exist.
      */
-    public void addIfNotPresent(Annotation ann)
+    public boolean addIfNotPresent(Annotation ann)
     {
         if (_annotations == null || !_annotations.containsKey(ann.annotationType())) {
             _add(ann);
+            return true;
         }
+        return false;
     }
 
     /**
      * Method called to add specified annotation in the Map.
      */
-    public void add(Annotation ann) {
-        _add(ann);
+    public boolean add(Annotation ann) {
+        return _add(ann);
     }
 
     @Override
@@ -99,11 +101,12 @@ public String toString() {
     /**********************************************************
      */
 
-    protected final void _add(Annotation ann) {
+    protected final boolean _add(Annotation ann) {
         if (_annotations == null) {
             _annotations = new HashMap<Class<? extends Annotation>,Annotation>();
         }
-        _annotations.put(ann.annotationType(), ann);
+        Annotation previous = _annotations.put(ann.annotationType(), ann);
+        return (previous != null) && previous.equals(ann);
     }
 }
 

src/test/java/com/fasterxml/jackson/databind/introspect/TestAnnotionBundles.java

@@ -3,9 +3,13 @@
 import java.lang.annotation.Retention;
 import java.lang.annotation.RetentionPolicy;
 
-import com.fasterxml.jackson.annotation.*;
+import com.fasterxml.jackson.annotation.JacksonAnnotationsInside;
+import com.fasterxml.jackson.annotation.JsonAutoDetect;
 import com.fasterxml.jackson.annotation.JsonAutoDetect.Visibility;
+import com.fasterxml.jackson.annotation.JsonIgnore;
+import com.fasterxml.jackson.annotation.JsonProperty;
 import com.fasterxml.jackson.databind.ObjectMapper;
+import com.fasterxml.jackson.databind.PropertyName;
 
 /* Tests mostly for [JACKSON-754]: ability to create "annotation bundles"
  */
@@ -51,15 +55,63 @@ public class NoAutoDetect {
     public class Bean92 {
         @Bundle92
         protected String id = "abc";
-    }    
+    }
+
+    @HolderB
+    @JacksonAnnotationsInside
+    @Retention(RetentionPolicy.RUNTIME)
+    static @interface HolderA {}
+
+    @HolderA
+    @JacksonAnnotationsInside
+    @Retention(RetentionPolicy.RUNTIME)
+    static @interface HolderB {}
+
+    static class HolderHolder {
+        @HolderA
+        @InformativeHolder
+        public int unimportant = 42;
+    }
+
+    @JsonProperty
+    @JacksonAnnotationsInside
+    @Retention(RetentionPolicy.RUNTIME)
+    static @interface InformativeHolder {
+        // doesn't really contribute to the test, but would be impossible without this feature
+        boolean important() default true;
+    }
+
+    static class BundleAnnotationIntrospector extends JacksonAnnotationIntrospector {
+        @Override
+        public PropertyName findNameForSerialization(Annotated a)
+        {
+            InformativeHolder informativeHolder = a.getAnnotation(InformativeHolder.class);
+            if ((informativeHolder != null) && informativeHolder.important()) {
+                return new PropertyName("important");
+            }
+            return super.findNameForSerialization(a);
+        }
+    }
+
     /*
     /**********************************************************
     /* Test methods
     /**********************************************************
      */
 
     private final ObjectMapper MAPPER = new ObjectMapper();
-    
+
+    public void testKeepAnnotationBundle() throws Exception
+    {
+        MAPPER.setAnnotationIntrospector(new BundleAnnotationIntrospector());
+        assertEquals("{\"important\":42}", MAPPER.writeValueAsString(new HolderHolder()));
+    }
+
+    public void testRecursiveBundles() throws Exception
+    {
+        assertEquals("{\"unimportant\":42}", MAPPER.writeValueAsString(new HolderHolder()));
+    }
+
     public void testBundledIgnore() throws Exception
     {
         assertEquals("{\"foobar\":13}", MAPPER.writeValueAsString(new Bean()));