Merge branch '2.6'

Conflicts:
	release-notes/VERSION

Author: cowtowncoder

release-notes/VERSION

@@ -10,6 +10,11 @@ Project: jackson-databind
  (contributed by David H)
 #933:Close some gaps to allow using the tryToResolveUnresolved flows
 
+2.6.3 (not yet released)
+
+#938: Regression: `StackOverflowError` with recursive types that contain `Map.Entry`
+ (reported by jloisel@github)
+
 2.6.2 (14-Sep-2015)
 
 #894: When using withFactory on ObjectMapper, the created Factory has a TypeParser

src/main/java/com/fasterxml/jackson/databind/type/TypeFactory.java

@@ -381,6 +381,24 @@ public JavaType[] findTypeParameters(JavaType type, Class<?> expType)
         return findTypeParameters(raw, expType, new TypeBindings(this, type));
     }
 
+    /**
+     * @since 2.7
+     */
+    public JavaType[] findTypeParameters(JavaType type, Class<?> expType, TypeBindings bindings)
+    {
+        if (expType == type.getParameterSource()) {
+            int count = type.containedTypeCount();
+            if (count == 0) return null;
+            JavaType[] result = new JavaType[count];
+            for (int i = 0; i < count; ++i) {
+                result[i] = type.containedType(i);
+            }
+            return result;
+        }
+        Class<?> raw = type.getRawClass();
+        return findTypeParameters(raw, expType, bindings);
+    }
+
     public JavaType[] findTypeParameters(Class<?> clz, Class<?> expType) {
         return findTypeParameters(clz, expType, new TypeBindings(this, clz));
     }
@@ -1003,6 +1021,8 @@ protected JavaType _fromParamType(ParameterizedType type, TypeBindings context)
         if (Map.class.isAssignableFrom(rawType)) {
             // 19-Mar-2015, tatu: Looks like 2nd arg ought to be Map.class, but that causes fails
             JavaType subtype = constructSimpleType(rawType, rawType, pt);
+            // 23-Sep-2015, tatu: and why do we not pass 3rd arg of 'context'? Won't help, it seems,
+            //   plus causes other issues. Sigh.
             JavaType[] mapParams = findTypeParameters(subtype, Map.class);
             if (mapParams.length != 2) {
                 throw new IllegalArgumentException("Could not find 2 type parameters for Map class "+rawType.getName()+" (found "+mapParams.length+")");
@@ -1027,8 +1047,9 @@ protected JavaType _fromParamType(ParameterizedType type, TypeBindings context)
                     rt = pt[0];
                 }
             } else {
-                JavaType[] pts = findTypeParameters(rawType, AtomicReference.class);
-                if (pts != null && pts.length != 1) {
+                JavaType subtype = constructSimpleType(rawType, rawType, pt);
+                JavaType[] pts = findTypeParameters(subtype, AtomicReference.class, context);
+                if (pts != null && pts.length == 1) {
                     rt = pts[0];
                 }
             }
@@ -1043,8 +1064,11 @@ protected JavaType _fromParamType(ParameterizedType type, TypeBindings context)
                     vt = pt[1];
                 }
             } else {
-                JavaType[] pts = findTypeParameters(rawType, Map.Entry.class);
-                if (pts != null && pts.length != 2) {
+                // 23-Sep-2015, tatu: Must be careful here; type resolution can NOT be done
+                //    directly quite yet. Instead, need to do indirectly...
+                JavaType subtype = constructSimpleType(rawType, rawType, pt);
+                JavaType[] pts = findTypeParameters(subtype, Map.Entry.class, context);
+                if (pts != null && pts.length == 2) {
                     kt = pts[0];
                     vt = pts[1];
                 }

src/test/java/com/fasterxml/jackson/databind/type/RecursiveType938Test.java

@@ -0,0 +1,57 @@
+package com.fasterxml.jackson.databind.type;
+
+import java.util.*;
+
+import com.fasterxml.jackson.databind.*;
+
+// for [databind#938]
+public class RecursiveType938Test extends BaseMapTest
+{
+    public static interface Ability<T> { }
+
+    public static final class ImmutablePair<L, R> implements Map.Entry<L, R>, Ability<ImmutablePair<L, R>> {
+        public final L key;
+        public final R value;
+
+        public ImmutablePair(final L key, final R value) {
+            this.key = key;
+            this.value = value;
+        }
+
+        @Override
+        public L getKey() {
+            return key;
+        }
+
+        @Override
+        public R getValue() {
+            return value;
+        }
+
+        @Override
+        public R setValue(final R value) {
+            throw new UnsupportedOperationException();
+        }
+      
+        static <L, R> ImmutablePair<L, R> of(final L left, final R right) {
+            return new ImmutablePair<L, R>(left, right);
+        }
+    }
+
+    private final ObjectMapper MAPPER = new ObjectMapper();
+
+    public void testRecursivePair() throws Exception
+    {
+        JavaType t = MAPPER.constructType(ImmutablePair.class);
+
+        assertNotNull(t);
+        assertEquals(ImmutablePair.class, t.getRawClass());
+
+        /*
+        List<ImmutablePair<String, Double>> list = new ArrayList<ImmutablePair<String, Double>>();
+        list.add(ImmutablePair.of("Hello World!", 123d));
+        String json = MAPPER.writeValueAsString(list);
+        assertNotNull(json);
+        */
+    }
+}