Support defaultImpl and FAIL_ON_INVALID_SUBTYPE features when using subtype deduction (#3057)

Author: drekbour

src/main/java/com/fasterxml/jackson/databind/DeserializationContext.java

@@ -1938,7 +1938,7 @@ public JsonMappingException invalidTypeIdException(JavaType baseType, String typ
      */
     public JsonMappingException missingTypeIdException(JavaType baseType,
             String extraDesc) {
-        String msg = String.format("Missing type id when trying to resolve subtype of %s",
+        String msg = String.format("Could not resolve subtype of %s",
                 baseType);
         return InvalidTypeIdException.from(_parser, _colonConcat(msg, extraDesc), baseType, null);
     }

src/main/java/com/fasterxml/jackson/databind/jsontype/impl/AsDeductionTypeDeserializer.java

@@ -3,13 +3,10 @@
 import java.io.IOException;
 import java.util.*;
 
-import com.fasterxml.jackson.annotation.JsonTypeInfo;
-
 import com.fasterxml.jackson.core.JsonParser;
 import com.fasterxml.jackson.core.JsonToken;
 
 import com.fasterxml.jackson.databind.*;
-import com.fasterxml.jackson.databind.exc.InvalidTypeIdException;
 import com.fasterxml.jackson.databind.introspect.BeanPropertyDefinition;
 import com.fasterxml.jackson.databind.jsontype.NamedType;
 import com.fasterxml.jackson.databind.jsontype.TypeDeserializer;
@@ -21,6 +18,11 @@
  * A {@link TypeDeserializer} capable of deducing polymorphic types based on the fields available. Deduction
  * is limited to the <i>names</i> of child fields (not their values or, consequently, any nested descendants).
  * Exceptions will be thrown if not enough unique information is present to select a single subtype.
+ * <p>
+ * The current deduction process <b>does not</b> support pojo-hierarchies such that the
+ * absence of child fields infers a parent type. That is, every deducible subtype
+ * MUST have some unique fields and the input data MUST contain said unique fields
+ * to provide a <i>positive match</i>.
  */
 public class AsDeductionTypeDeserializer extends AsPropertyTypeDeserializer
 {
@@ -32,7 +34,7 @@ public class AsDeductionTypeDeserializer extends AsPropertyTypeDeserializer
     private final Map<BitSet, String> subtypeFingerprints;
 
     public AsDeductionTypeDeserializer(JavaType bt, TypeIdResolver idRes, JavaType defaultImpl, DeserializationConfig config, Collection<NamedType> subtypes) {
-        super(bt, idRes, null, false, defaultImpl);
+        super(bt, idRes, null, false, defaultImpl, null);
         fieldBitIndex = new HashMap<>();
         subtypeFingerprints = buildFingerprints(config, subtypes);
     }
@@ -43,11 +45,6 @@ public AsDeductionTypeDeserializer(AsDeductionTypeDeserializer src, BeanProperty
         subtypeFingerprints = src.subtypeFingerprints;
     }
 
-    @Override
-    public JsonTypeInfo.As getTypeInclusion() {
-        return null;
-    }
-
     @Override
     public TypeDeserializer forProperty(BeanProperty prop) {
         return (prop == _property) ? this : new AsDeductionTypeDeserializer(this, prop);
@@ -93,15 +90,15 @@ public Object deserializeTypedFromObject(JsonParser p, DeserializationContext ct
         JsonToken t = p.currentToken();
         if (t == JsonToken.START_OBJECT) {
             t = p.nextToken();
-        } else {
+        } else if (/*t == JsonToken.START_ARRAY ||*/ t != JsonToken.FIELD_NAME) {
             /* This is most likely due to the fact that not all Java types are
              * serialized as JSON Objects; so if "as-property" inclusion is requested,
              * serialization of things like Lists must be instead handled as if
              * "as-wrapper-array" was requested.
              * But this can also be due to some custom handling: so, if "defaultImpl"
              * is defined, it will be asked to handle this case.
              */
-            return _deserializeTypedUsingDefaultImpl(p, ctxt, null);
+            return _deserializeTypedUsingDefaultImpl(p, ctxt, null, "Unexpected input");
         }
 
         List<BitSet> candidates = new LinkedList<>(subtypeFingerprints.keySet());
@@ -127,13 +124,9 @@ public Object deserializeTypedFromObject(JsonParser p, DeserializationContext ct
             }
         }
 
-        throw new InvalidTypeIdException(p,
-                String.format("Cannot deduce unique subtype of %s (%d candidates match)",
-                        ClassUtil.getTypeDescription(_baseType),
-                        candidates.size()),
-                _baseType
-                , "DEDUCED"
-        );
+        // We have zero or multiple candidates, deduction has failed
+        String msgToReportIfDefaultImplFailsToo = String.format("Cannot deduce unique subtype of %s (%d candidates match)", ClassUtil.getTypeDescription(_baseType), candidates.size());
+        return _deserializeTypedUsingDefaultImpl(p, ctxt, tb, msgToReportIfDefaultImplFailsToo);
     }
 
     // Keep only fingerprints containing this field

src/main/java/com/fasterxml/jackson/databind/jsontype/impl/AsPropertyTypeDeserializer.java

@@ -31,6 +31,10 @@ public class AsPropertyTypeDeserializer extends AsArrayTypeDeserializer
 
     protected final As _inclusion;
 
+    protected final String msgMissingId = _property == null ?
+      String.format("missing type id property '%s'", _typePropertyName) :
+      String.format("missing type id property '%s' (for POJO property '%s')", _typePropertyName, _property.getName());
+
     /**
      * @since 2.8
      */
@@ -91,7 +95,7 @@ public Object deserializeTypedFromObject(JsonParser p, DeserializationContext ct
              * But this can also be due to some custom handling: so, if "defaultImpl"
              * is defined, it will be asked to handle this case.
              */
-            return _deserializeTypedUsingDefaultImpl(p, ctxt, null);
+            return _deserializeTypedUsingDefaultImpl(p, ctxt, null, msgMissingId);
         }
         // Ok, let's try to find the property. But first, need token buffer...
         TokenBuffer tb = null;
@@ -110,7 +114,7 @@ public Object deserializeTypedFromObject(JsonParser p, DeserializationContext ct
             tb.writeFieldName(name);
             tb.copyCurrentStructure(p);
         }
-        return _deserializeTypedUsingDefaultImpl(p, ctxt, tb);
+        return _deserializeTypedUsingDefaultImpl(p, ctxt, tb, msgMissingId);
     }
 
     protected Object _deserializeTypedForId(JsonParser p, DeserializationContext ctxt,
@@ -137,7 +141,7 @@ protected Object _deserializeTypedForId(JsonParser p, DeserializationContext ctx
 
     // off-lined to keep main method lean and mean...
     protected Object _deserializeTypedUsingDefaultImpl(JsonParser p,
-            DeserializationContext ctxt, TokenBuffer tb) throws IOException
+            DeserializationContext ctxt, TokenBuffer tb, String priorFailureMsg) throws IOException
     {
         // May have default implementation to use
         // 13-Oct-2020, tatu: As per [databind#2775], need to be careful to
@@ -165,13 +169,7 @@ protected Object _deserializeTypedUsingDefaultImpl(JsonParser p,
         // genuine, or faked for "dont fail on bad type id")
         JsonDeserializer<Object> deser = _findDefaultImplDeserializer(ctxt);
         if (deser == null) {
-            String msg = String.format("missing type id property '%s'",
-                    _typePropertyName);
-            // even better, may know POJO property polymorphic value would be assigned to
-            if (_property != null) {
-                msg = String.format("%s (for POJO property '%s')", msg, _property.getName());
-            }
-            JavaType t = _handleMissingTypeId(ctxt, msg);
+            JavaType t = _handleMissingTypeId(ctxt, priorFailureMsg);
             if (t == null) {
                 // 09-Mar-2017, tatu: Is this the right thing to do?
                 return null;

src/test/java/com/fasterxml/jackson/databind/jsontype/JsonTypeInfoCaseInsensitive1983Test.java

@@ -54,7 +54,7 @@ public void testReadMixedCasePropertyName() throws Exception
             MAPPER.readValue(serialised, Filter.class);
             fail("Should not pass");
         } catch (InvalidTypeIdException e) {
-            verifyException(e, "Missing type id when trying to resolve subtype");
+            verifyException(e, "missing type id property");
         }
 
         ObjectMapper mapper = jsonMapperBuilder()

src/test/java/com/fasterxml/jackson/databind/jsontype/TestPolymorphicDeduction.java

@@ -22,28 +22,16 @@ public class TestPolymorphicDeduction extends BaseMapTest {
 
   @JsonTypeInfo(use = DEDUCTION)
   @JsonSubTypes( {@Type(LiveCat.class), @Type(DeadCat.class)})
-  static abstract class Cat {
-    public final String name;
-
-    protected Cat(String name) {
-      this.name = name;
-    }
+  public static class Cat {
+    public String name;
   }
 
   static class DeadCat extends Cat {
     public String causeOfDeath;
-
-    DeadCat(@JsonProperty("name") String name) {
-      super(name);
-    }
   }
 
   static class LiveCat extends Cat {
     public boolean angry;
-
-    LiveCat(@JsonProperty("name") String name) {
-      super(name);
-    }
   }
 
   static class Box {
@@ -155,10 +143,6 @@ public void testIgnoreProperties() throws Exception {
 
   static class AnotherLiveCat extends Cat {
     public boolean angry;
-
-    AnotherLiveCat(@JsonProperty("name") String name) {
-      super(name);
-    }
   }
 
   public void testAmbiguousClasses() throws Exception {
@@ -180,10 +164,40 @@ public void testAmbiguousProperties() throws Exception {
       /*Cat cat =*/ sharedMapper().readValue(ambiguousCatJson, Cat.class);
       fail("Should not get here");
     } catch (InvalidTypeIdException e) {
-        verifyException(e, "Cannot deduce unique subtype of");
+        verifyException(e, "Cannot deduce unique subtype");
     }
   }
 
+  public void testFailOnInvalidSubtype() throws Exception {
+    // Given:
+    JsonMapper mapper = JsonMapper.builder() // Don't use shared mapper!
+      .disable(DeserializationFeature.FAIL_ON_INVALID_SUBTYPE)
+      .build();
+    // When:
+    Cat cat = mapper.readValue(ambiguousCatJson, Cat.class);
+    // Then:
+    assertNull(cat);
+  }
+
+  @JsonTypeInfo(use = DEDUCTION, defaultImpl = Cat.class)
+  abstract static class CatMixin {
+  }
+
+  public void testDefaultImpl() throws Exception {
+    // Given:
+    JsonMapper mapper = JsonMapper.builder() // Don't use shared mapper!
+      .addMixIn(Cat.class, CatMixin.class)
+      .disable(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES)
+      .build();
+    // When:
+    Cat cat = mapper.readValue(ambiguousCatJson, Cat.class);
+    // Then:
+    // Even though "age":2 implies this was a failed subtype, we are instructed to fallback to Cat regardless.
+    assertTrue(cat instanceof Cat);
+    assertSame(Cat.class, cat.getClass());
+    assertEquals("Felix", cat.name);
+  }
+
   public void testSimpleSerialization() throws Exception {
     // Given:
     JavaType listOfCats = TypeFactory.defaultInstance().constructParametricType(List.class, Cat.class);