Allow registering the same subtype multiple times

Before this commit NamedType hashes only on it's class and not on the
name. This only allowed you to register a class once using
ObjectMapper.registerSubtypes(NamedType... types). This commit now
uses name field to hash NamedTypes.

This successfully allows you to deserialize objects of the same type
but different name.

Serializing objects of the same type but different name (for example
fields of a POJO) still has some issues.
1. SerializerProvider caches Serializers based on class and doesn't
take name into account.
2. TypeIdResolver has no method to resolve an id that takes name into
account. Therefore when resolving an id we only have the value and
type.
3. TypeNameIdResolver stores type and id information as a
Map<String, String> that maps type to id, ignoring name

Fixes FasterXML#2515

Author: jkosh44

Diff for: src/main/java/com/fasterxml/jackson/databind/jsontype/NamedType.java

@@ -14,10 +14,10 @@ public final class NamedType implements java.io.Serializable
     protected String _name;
 
     public NamedType(Class<?> c) { this(c, null); }
-    
+
     public NamedType(Class<?> c, String name) {
         _class = c;
-        _hashCode = c.getName().hashCode();
+        _hashCode = (c.getName() + (name != null ? name : "")).hashCode();
         setName(name);
     }
 

Diff for: src/main/java/com/fasterxml/jackson/databind/jsontype/impl/StdSubtypeResolver.java

@@ -112,7 +112,8 @@ public Collection<NamedType> collectAndResolveSubtypesByClass(MapperConfig<?> co
             AnnotatedClass type)
     {
         final AnnotationIntrospector ai = config.getAnnotationIntrospector();
-        HashMap<NamedType, NamedType> subtypes = new HashMap<NamedType, NamedType>();
+        HashMap<NamedType, NamedType> subtypes = new HashMap<>();
+
         // then consider registered subtypes (which have precedence over annotations)
         if (_registeredSubtypes != null) {
             Class<?> rawBase = type.getRawType();
@@ -223,19 +224,23 @@ protected void _collectAndResolve(AnnotatedClass annotatedType, NamedType namedT
             }
         }
 
+        //For Serialization we only want to return a single NamedType per class so it's
+        //unambiguous what name we use.
+        NamedType typeOnlyNamedType = new NamedType(namedType.getType());
+
         // First things first: is base type itself included?
-        if (collectedSubtypes.containsKey(namedType)) {
+        if (collectedSubtypes.containsKey(typeOnlyNamedType)) {
             // if so, no recursion; however, may need to update name?
             if (namedType.hasName()) {
-                NamedType prev = collectedSubtypes.get(namedType);
+                NamedType prev = collectedSubtypes.get(typeOnlyNamedType);
                 if (!prev.hasName()) {
-                    collectedSubtypes.put(namedType, namedType);
+                    collectedSubtypes.put(typeOnlyNamedType, namedType);
                 }
             }
             return;
         }
         // if it wasn't, add and check subtypes recursively
-        collectedSubtypes.put(namedType, namedType);
+        collectedSubtypes.put(typeOnlyNamedType, namedType);
         Collection<NamedType> st = ai.findSubtypes(annotatedType);
         if (st != null && !st.isEmpty()) {
             for (NamedType subtype : st) {

Diff for: src/test/java/com/fasterxml/jackson/databind/jsontype/TestSubtypes.java

@@ -4,6 +4,7 @@
 
 import java.util.*;
 
+import com.fasterxml.jackson.annotation.JsonProperty;
 import com.fasterxml.jackson.annotation.JsonSubTypes;
 import com.fasterxml.jackson.annotation.JsonTypeInfo;
 import com.fasterxml.jackson.annotation.JsonTypeName;
@@ -38,7 +39,7 @@ static class SubD extends SuperType {
     // "Empty" bean
     @JsonTypeInfo(use=JsonTypeInfo.Id.NAME)
     static abstract class BaseBean { }
-    
+
     static class EmptyBean extends BaseBean { }
 
     static class EmptyNonFinal { }
@@ -49,7 +50,7 @@ static class PropertyBean
     {
         @JsonTypeInfo(use=JsonTypeInfo.Id.NAME)
         public SuperType value;
-        
+
         public PropertyBean() { this(null); }
         public PropertyBean(SuperType v) { value = v; }
     }
@@ -70,6 +71,28 @@ static class DefaultImpl505 extends SuperTypeWithoutDefault {
         public int a;
     }
 
+    static class Sub extends SuperTypeWithoutDefault {
+        public int a;
+
+        public Sub(){}
+        public Sub(int a) {
+            this.a = a;
+        }
+    }
+
+    static class POJOWrapper {
+        @JsonProperty
+        Sub sub1;
+        @JsonProperty
+        Sub sub2;
+
+        public POJOWrapper(){}
+        public POJOWrapper(Sub sub1, Sub sub2) {
+            this.sub1 = sub1;
+            this.sub2 = sub2;
+        }
+    }
+
     @JsonTypeInfo(use=JsonTypeInfo.Id.NAME, include=As.PROPERTY, property="type")
     @JsonSubTypes({ @JsonSubTypes.Type(ImplX.class),
           @JsonSubTypes.Type(ImplY.class) })
@@ -118,7 +141,7 @@ static class Issue1125Wrapper {
         public Issue1125Wrapper() { }
         public Issue1125Wrapper(Base1125 v) { value = v; }
     }
-    
+
     @JsonTypeInfo(use=JsonTypeInfo.Id.NAME, defaultImpl=Default1125.class)
     @JsonSubTypes({ @JsonSubTypes.Type(Interm1125.class) })
     static class Base1125 {
@@ -204,7 +227,7 @@ public void testSubtypesViaModule() throws Exception
         result = mapper.readValue(json, PropertyBean.class);
         assertSame(SubC.class, result.value.getClass());
     }
-    
+
     public void testSerialization() throws Exception
     {
         // serialization can detect type name ok without anything extra:
@@ -216,8 +239,12 @@ public void testSerialization() throws Exception
         mapper.registerSubtypes(new NamedType(SubB.class, "typeB"));
         assertEquals("{\"@type\":\"typeB\",\"b\":1}", mapper.writeValueAsString(bean));
 
+        // the first registered type name is used for serialization
+        mapper.registerSubtypes(new NamedType(SubB.class, "ignoredOnSerialization"));
+        assertEquals("{\"@type\":\"typeB\",\"b\":1}", mapper.writeValueAsString(bean));
+
         // and default name ought to be simple class name; with context
-        assertEquals("{\"@type\":\"TestSubtypes$SubD\",\"d\":0}", mapper.writeValueAsString(new SubD()));  
+        assertEquals("{\"@type\":\"TestSubtypes$SubD\",\"d\":0}", mapper.writeValueAsString(new SubD()));
     }
 
     public void testDeserializationNonNamed() throws Exception
@@ -236,6 +263,7 @@ public void testDeserializatioNamed() throws Exception
         ObjectMapper mapper = new ObjectMapper();
         mapper.registerSubtypes(SubB.class);
         mapper.registerSubtypes(new NamedType(SubD.class, "TypeD"));
+        mapper.registerSubtypes(new NamedType(SubD.class, "typeD"));
 
         SuperType bean = mapper.readValue("{\"@type\":\"TypeB\", \"b\":13}", SuperType.class);
         assertSame(SubB.class, bean.getClass());
@@ -245,6 +273,24 @@ public void testDeserializatioNamed() throws Exception
         bean = mapper.readValue("{\"@type\":\"TypeD\", \"d\":-4}", SuperType.class);
         assertSame(SubD.class, bean.getClass());
         assertEquals(-4, ((SubD) bean).d);
+
+        // we can register the same subtype under two names
+        bean = mapper.readValue("{\"@type\":\"typeD\", \"d\":-4}", SuperType.class);
+        assertSame(SubD.class, bean.getClass());
+        assertEquals(-4, ((SubD) bean).d);
+
+    }
+
+    public void testDeserializationWithDuplicateRegisteredSubtypes()
+        throws Exception {
+        ObjectMapper mapper = new ObjectMapper();
+        mapper.registerSubtypes(new NamedType(Sub.class, "sub1"));
+        mapper.registerSubtypes(new NamedType(Sub.class, "sub2"));
+
+        POJOWrapper pojoWrapper = mapper.readValue("{\"sub1\":{\"#type\":\"sub1\",\"a\":10},\"sub2\":{\"#type\":\"sub2\",\"a\":50}}", POJOWrapper.class);
+
+        assertEquals(10, pojoWrapper.sub1.a);
+        assertEquals(50, pojoWrapper.sub2.a);
     }
 
     // Trying to reproduce [JACKSON-366]
@@ -295,7 +341,7 @@ public void testDefaultImpl() throws Exception
     public void testDefaultImplViaModule() throws Exception
     {
         final String JSON = "{\"a\":123}";
-        
+
         // first: without registration etc, epic fail:
         try {
             MAPPER.readValue(JSON, SuperTypeWithoutDefault.class);
@@ -317,7 +363,7 @@ public void testDefaultImplViaModule() throws Exception
         bean = mapper.readValue("{\"#type\":\"foobar\"}", SuperTypeWithoutDefault.class);
         assertEquals(DefaultImpl505.class, bean.getClass());
         assertEquals(0, ((DefaultImpl505) bean).a);
-    
+
     }
 
     public void testErrorMessage() throws Exception {
@@ -361,7 +407,7 @@ public void testSubclassLimits() throws Exception
     public void testIssue1125NonDefault() throws Exception
     {
         String json = MAPPER.writeValueAsString(new Issue1125Wrapper(new Impl1125(1, 2, 3)));
-        
+
         Issue1125Wrapper result = MAPPER.readValue(json, Issue1125Wrapper.class);
         assertNotNull(result.value);
         assertEquals(Impl1125.class, result.value.getClass());
@@ -374,7 +420,7 @@ public void testIssue1125NonDefault() throws Exception
     public void testIssue1125WithDefault() throws Exception
     {
         Issue1125Wrapper result = MAPPER.readValue(aposToQuotes("{'value':{'a':3,'def':9,'b':5}}"),
-        		Issue1125Wrapper.class);
+                      Issue1125Wrapper.class);
         assertNotNull(result.value);
         assertEquals(Default1125.class, result.value.getClass());
         Default1125 impl = (Default1125) result.value;