Behaviour of JsonAutoDetect with Mixins

[jwgmeligmeyling]

When having the following classes:

public static class SomeClass {
    public String a = "a", b = "b";
}

private static class SomeMixin {
    public String a;
}

Serializing SomeClass with SomeMixin as mixin, results in both fields a and b being serialized. This is because AUTO_DETECT_FIELDS is enabled by default, which also discovers the fields on SomeClass. When disabling AUTO_DETECT_FIELDS the mixin works as expected, as long as a is annotated with JsonProperty:

private static class SomeMixin {
    @JsonProperty
    public String a;
}

ObjectMapper mapper = new ObjectMapper();
mapper.disable(MapperFeature.AUTO_DETECT_FIELDS);
mapper.addMixIn(SomeClass.class, SomeMixin.class);
System.out.println(mapper.writeValueAsString(new SomeClass()));

Result:

{"a":"a"}

I was however surprised to see that when SomeMixin is annotated with JsonAutoDetect(fieldVisibility = PUBLIC_ONLY), both fields are serialised again. From the documentation of Mixins it became clear that all annotations from the mixin are copied to the target, thus including the JsonAutoDetect annotation. I understand that decision but its somewhat also counter intuitive that an annotation on a mixin can leak fields from a target unintentionally:

@JsonAutoDetect(fieldVisibility = JsonAutoDetect.Visibility.PUBLIC_ONLY)
private static class SomeMixin {
    @JsonProperty
    public String a;
}

Result:

{"a":"a","b":"b"}

Now I was wondering whether existing API's exist to tweak this behaviour? Perhaps its possible through an AnnotationIntrospector to ignore the JsonAutoDetect annotation inherited through mixins?

(Fields used as example here, the same behaviour obviously exists for getters and setters too)

[cowtowncoder]

I am not sure why this would be considered leakage -- intent of mix-ins is to provide annotations. So why would it by surprising annotations was indeed used? Put another way, why would mix-in have @JsonAutoDetect in the first place?
Also: class annotations have precedence over global defaults, being more specific.

As to AnnotationIntrospector: no, introspector has no idea annotation comes from mix-ins -- all it sees is a flattened set of annotations of introspected class (so annotations can come from super types as well as mix-ins).
So there is no way to exclude annotations from mix-ins.

But I feel I am missing something here, wrt intended usage.