Leave Java enums entirely to Jackson

[pjfanning]

Split out of #1 so it can land independently — this touches only enum handling and nothing to do with registration.

An enum permitted by a handled root was being written as a tagged object with a name per constant, {"@type":"Status$IDLE"}, taking over a representation Jackson already has. Enums are now skipped everywhere: Jackson writes them as strings and this module does not interfere.

public sealed interface Signal extends SealedPolymorphismSupport permits Data, Status {}
public record Data(int value) implements Signal {}
public enum Status implements Signal { IDLE, BUSY }

{"signal":{"@type":"Data","value":1}}   // the record is tagged
{"signal":"IDLE"}                       // the enum is not

Putting the marker on an enum is no longer an error either — it simply has no effect, since an enum is written as a string however it is declared.

Net deletion

Enum constants were the only thing a resolved name could be other than a class, so this removes more than it adds: Subtype and its singleton field, TypeTaggedEnumSerializer, TaggedEnumDeserializer, and both enum modifier hooks are gone. A name now resolves to a Class and nothing else.

One consequence, worth a look in review

An enum member has no @type name, so a value of one cannot be read back through the hierarchy's base type — a string is not something the base can dispatch on. Writing works; reading works wherever the property is declared as the enum type itself.

Rather than surface that as a bare token mismatch, the failure now names the enums the hierarchy permits and points at the alternatives (declare the property as the enum type, or use a no-component record, which writes {"@type":"Unknown"} and reads straight back). It is pinned by a test and documented in the README.

If that asymmetry is unwanted, the fix would be to let the base deserializer accept a JSON string as naming an enum constant — read-side only, leaving Jackson's string output untouched. Not done here.

Tests

The enum tests are kept with corrected assertions. EnumsUntouchedTest proves non-interference the strongest way available: it writes each value through a mapper carrying the module and through a plain one and asserts the two agree, which catches differences that were not predicted. It covers enums declared at the base type and at their own type, in collections, as Map keys, with a custom @JsonValue, and with constant bodies — that last being implicitly sealed and abstract with each constant an anonymous subclass, so it reaches every sealed check the module makes.

76 tests, passing on JDK 17, 21 and 25.

🤖 Generated with Claude Code

https://claude.ai/code/session_012hxYY9KPDAMXADWzjBHNV4